softable-pixels-web 1.0.0

package/dist/mask-modules.js

@@ -0,0 +1,705 @@
+//#region src/services/MaskModule/MaskModule.ts
+const locales = {};
+function ensureLocale(locale) {
+	if (!locales[locale]) locales[locale] = {
+		masks: {},
+		validators: {}
+	};
+}
+const MaskModule = {
+	registerMask(locale, type, mask) {
+		ensureLocale(locale);
+		locales[locale].masks[type] = mask;
+	},
+	registerValidator(locale, type, validator) {
+		ensureLocale(locale);
+		locales[locale].validators[type] = validator;
+	},
+	getMask(locale, type) {
+		return locales[locale]?.masks[type];
+	},
+	getValidator(locale, type) {
+		return locales[locale]?.validators[type];
+	},
+	reset() {
+		Object.keys(locales).forEach((locale) => {
+			delete locales[locale];
+		});
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/enums.ts
+/**
+* Supported locales (country + language region).
+*
+* Extend this enum as needed for new countries.
+*/
+let Locale = /* @__PURE__ */ function(Locale$1) {
+	Locale$1["BR"] = "pt-BR";
+	Locale$1["US"] = "en-US";
+	Locale$1["AR"] = "es-AR";
+	return Locale$1;
+}({});
+/**
+* Types of masks supported in the system.
+*
+* Add new types as needed for different data formats.
+*/
+let MaskType = /* @__PURE__ */ function(MaskType$1) {
+	MaskType$1["CPF"] = "CPF";
+	MaskType$1["CNPJ"] = "CNPJ";
+	MaskType$1["DOCUMENT"] = "DOCUMENT";
+	MaskType$1["PHONE"] = "PHONE";
+	MaskType$1["DATE"] = "DATE";
+	MaskType$1["FLOAT"] = "FLOAT";
+	MaskType$1["INTEGER"] = "INTEGER";
+	MaskType$1["MONEY"] = "MONEY";
+	MaskType$1["ZIP_CODE"] = "ZIP_CODE";
+	MaskType$1["NUMERIC_SYMBOL"] = "NUMERIC_SYMBOL";
+	return MaskType$1;
+}({});
+
+//#endregion
+//#region src/services/MaskModule/base/maskUtils.ts
+/**
+* Removes all non-numeric characters from a string.
+* @param value - Input string.
+* @returns String containing only digits.
+*/
+function onlyDigits(value) {
+	if (value == null) return "";
+	return value.replace(/\D/g, "");
+}
+/**
+* Applies the mask progressively according to the available characters.
+*
+* Alphanumeric characters (letters and digits) in the pattern will be replaced
+* by characters from the input `value`, in order. Non-alphanumeric characters
+* (e.g. `.`, `-`, `/`) are treated as static parts of the mask.
+*
+* Examples:
+*
+* applyPattern('12345', 'XXX.XXX.XXX-XX') -> '123.45'
+*
+* applyPattern('AB1234', 'AA-NN.NN')      -> 'AB-12.34'
+*
+* applyPattern('12345678901', 'XXX.XXX.XXX-XX') -> '123.456.789-01'
+*
+* @param value - raw input string (partial or complete)
+* @param pattern - mask pattern where alphanumeric characters are placeholders
+* @returns partially formatted string
+*/
+function applyPattern(value, pattern) {
+	if (value == null) return "";
+	if (pattern == null) return value;
+	let result = "";
+	let digitIndex = 0;
+	for (let i = 0; i < pattern.length; i++) {
+		const char = pattern[i];
+		if (/[a-zA-Z0-9]/.test(char)) if (digitIndex < value.length) result += value[digitIndex++];
+		else break;
+		else if (digitIndex < value.length) result += char;
+	}
+	return result;
+}
+/**
+* Limits the length of a string to a maximum.
+* @param value - Input string.
+* @param maxLength - Maximum length allowed.
+* @returns Truncated string if longer than maxLength.
+*/
+function limitLength(value, maxLength) {
+	if (value == null) return "";
+	if (maxLength === void 0) return value;
+	return value.slice(0, maxLength);
+}
+
+//#endregion
+//#region src/services/MaskModule/base/BaseMask.ts
+/**
+* Abstract class that provides default behavior for most masks.
+* - Implements unmask() by removing all non-numeric characters.
+* - Supports optional maxLength and minLength constraints.
+*/
+var BaseMask = class {
+	/**
+	* Maximum length of the masked string (optional).
+	*/
+	maxLength;
+	/**
+	* Minimum length of the masked string (optional).
+	*/
+	minLength;
+	constructor(minLength, maxLength) {
+		this.maxLength = maxLength;
+		this.minLength = minLength;
+	}
+	/**
+	* Removes all non-numeric characters from a string.
+	* @param value - Masked or unmasked string.
+	* @returns Plain string with digits only.
+	*/
+	unmask(value) {
+		return onlyDigits(value);
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/CpfMask.ts
+const CPF_PATTERN = "XXX.XXX.XXX-XX";
+var CpfMask = class extends BaseMask {
+	constructor() {
+		const length = 14;
+		super(length, length);
+	}
+	format(value) {
+		return limitLength(applyPattern(onlyDigits(value), CPF_PATTERN), this.maxLength);
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/CnpjMask.ts
+const CNPJ_PATTERN = "XX.XXX.XXX/XXXX-XX";
+var CnpjMask = class extends BaseMask {
+	constructor() {
+		const length = 18;
+		super(length, length);
+	}
+	format(value) {
+		return limitLength(applyPattern(onlyDigits(value), CNPJ_PATTERN), this.maxLength);
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/DateMask.ts
+var DateMask = class extends BaseMask {
+	constructor() {
+		const length = 10;
+		super(length, length);
+	}
+	format(value) {
+		const digits = onlyDigits(value);
+		let day = digits.slice(0, 2);
+		let month = digits.slice(2, 4);
+		let year = digits.slice(4, 8);
+		if (day.length === 2) {
+			const parsed = parseInt(day);
+			if (parsed > 31) day = "31";
+			else if (parsed < 1) day = "01";
+		}
+		if (month.length === 2) {
+			const parsed = parseInt(month);
+			if (parsed > 12) month = "12";
+			else if (parsed < 1) month = "01";
+		}
+		if (year.length === 4) {
+			if (parseInt(year) < 0) year = "0000";
+		}
+		let result = "";
+		if (day) result += day;
+		if (month) result += `/${month}`;
+		if (year) result += `/${year}`;
+		return limitLength(result, this.maxLength);
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/PhoneMask.ts
+/**
+* Formats a Brazilian phone number progressively:
+* (XX) XXXXX-XXXX or (XX) XXXX-XXXX depending on length.
+*/
+var PhoneMask = class extends BaseMask {
+	constructor(maxLength = 15) {
+		super(14, maxLength);
+	}
+	format(value) {
+		const digits = limitLength(onlyDigits(value), this.maxLength);
+		if (!digits) return "";
+		if (digits.length < 3) return `(${digits}`;
+		const ddd = digits.slice(0, 2);
+		const rest = digits.slice(2);
+		if (rest.length <= 4) return `(${ddd}) ${rest}`;
+		else if (rest.length <= 8) {
+			const part1 = rest.slice(0, 4);
+			const part2 = rest.slice(4);
+			return `(${ddd}) ${part1}${part2 ? `-${part2}` : ""}`;
+		} else return `(${ddd}) ${rest.slice(0, 5)}-${rest.slice(5)}`;
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/FloatMask.ts
+/**
+* Automatically formats a numeric input as a float using comma as decimal separator.
+*
+* Ignores user-entered punctuation and inserts the comma based on configured decimal places.
+*/
+var FloatMask = class extends BaseMask {
+	maxDecimalPlaces;
+	constructor(decimalDigits = 2, maxLength = 20) {
+		super(1, maxLength);
+		this.maxDecimalPlaces = decimalDigits;
+	}
+	format(value) {
+		const digits = limitLength(onlyDigits(value), this.maxLength);
+		if (!digits) return "";
+		const length = digits.length;
+		if (length <= this.maxDecimalPlaces) {
+			const padded = digits.padStart(this.maxDecimalPlaces + 1, "0");
+			return `${padded.slice(0, padded.length - this.maxDecimalPlaces)},${padded.slice(-this.maxDecimalPlaces)}`;
+		}
+		const intPart = digits.slice(0, length - this.maxDecimalPlaces);
+		const decimalPart = digits.slice(-this.maxDecimalPlaces);
+		return `${this.formatThousands(intPart)},${decimalPart}`;
+	}
+	/**
+	* Adds dot thousand separators to a string of digits.
+	* Example: "1234567" => "1.234.567"
+	*/
+	formatThousands(value) {
+		return value.replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/MoneyMask.ts
+/**
+* Formats input as currency, with thousand separator, decimal comma,
+* optional prefix (e.g. R$, $), and support for negatives.
+*
+* Examples:
+* - "123456" → "R$ 1.234,56"
+* - "-123"   → "R$ -1,23"
+*/
+var MoneyMask = class extends BaseMask {
+	maxDecimalPlaces;
+	prefix;
+	allowNegative;
+	constructor({ prefix = "R$", maxDecimalPlaces = 2, allowNegative = true, maxLength = 20 } = {}) {
+		super(1, maxLength);
+		this.prefix = prefix;
+		this.maxDecimalPlaces = maxDecimalPlaces;
+		this.allowNegative = allowNegative;
+	}
+	format(value) {
+		if (!value) return "";
+		const isNegative = this.allowNegative && value.trim().startsWith("-");
+		const digits = onlyDigits(value).slice(0, this.maxLength);
+		if (!digits) return isNegative ? `${this.prefix} -0,${"0".repeat(this.maxDecimalPlaces)}` : `${this.prefix} 0,${"0".repeat(this.maxDecimalPlaces)}`;
+		const len = digits.length;
+		if (len <= this.maxDecimalPlaces) {
+			const padded = digits.padStart(this.maxDecimalPlaces + 1, "0");
+			const intPart = padded.slice(0, padded.length - this.maxDecimalPlaces);
+			const decimalPart = padded.slice(-this.maxDecimalPlaces);
+			return `${this.prefix} ${isNegative ? "-" : ""}${intPart},${decimalPart}`;
+		}
+		const intRaw = digits.slice(0, len - this.maxDecimalPlaces);
+		const decimal = digits.slice(-this.maxDecimalPlaces);
+		const intFormatted = this.formatThousands(intRaw);
+		return `${this.prefix} ${isNegative ? "-" : ""}${intFormatted},${decimal}`;
+	}
+	formatThousands(value) {
+		return value.replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/IntegerMask.ts
+/**
+* Formats integers, allowing only digits.
+*/
+var IntegerMask = class extends BaseMask {
+	constructor(maxLength = 15) {
+		super(1, maxLength);
+	}
+	format(value) {
+		return limitLength(onlyDigits(value), this.maxLength);
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/ZipCodeMask.ts
+const ZIP_CODE_PATTERN = "XXXXX-XXX";
+var ZipCodeMask = class extends BaseMask {
+	constructor() {
+		const length = 9;
+		super(length, length);
+	}
+	format(value) {
+		return limitLength(applyPattern(onlyDigits(value), ZIP_CODE_PATTERN), this.maxLength);
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/types.ts
+/**
+* Mode of document mask and validator.
+*
+* - AUTO: Automatically detect based on length.
+* - CPF: Force CPF.
+* - CNPJ: Force CNPJ.
+*/
+let DocumentMode = /* @__PURE__ */ function(DocumentMode$1) {
+	DocumentMode$1["CPF"] = "cpf";
+	DocumentMode$1["CNPJ"] = "cnpj";
+	DocumentMode$1["AUTO"] = "auto";
+	return DocumentMode$1;
+}({});
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/DocumentMask.ts
+var DocumentMask = class extends BaseMask {
+	cpfMask = new CpfMask();
+	cnpjMask = new CnpjMask();
+	mode;
+	constructor(mode = DocumentMode.AUTO) {
+		super();
+		this.mode = mode;
+	}
+	format(value) {
+		const digits = onlyDigits(value);
+		const mode = this.resolveMode(digits);
+		if (mode === DocumentMode.CPF) return this.cpfMask.format(digits);
+		if (mode === DocumentMode.CNPJ) return this.cnpjMask.format(digits);
+		return digits;
+	}
+	resolveMode(digits) {
+		if (this.mode === DocumentMode.CPF) return DocumentMode.CPF;
+		if (this.mode === DocumentMode.CNPJ) return DocumentMode.CNPJ;
+		return digits.length <= 11 ? DocumentMode.CPF : DocumentMode.CNPJ;
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/masks/NumericSymbolMask.ts
+var NumericSymbolMask = class extends BaseMask {
+	constructor(maxLength = 25) {
+		super(1, maxLength);
+	}
+	format(value) {
+		if (value == null) return "";
+		return limitLength(value.replace(/[^\d.,/-]/g, ""), this.maxLength);
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/base/BaseValidator.ts
+/**
+* Abstract class providing common validation utilities.
+* - Supports regex validation.
+* - Supports min and max length validation.
+*/
+var BaseValidator = class {
+	pattern;
+	minLength;
+	maxLength;
+	constructor(options) {
+		this.pattern = options?.pattern;
+		this.minLength = options?.minLength;
+		this.maxLength = options?.maxLength;
+	}
+	/**
+	* Validates the input value based on:
+	* - Pattern matching (if defined)
+	* - Min length (if defined)
+	* - Max length (if defined)
+	*
+	* Override this method if you need custom validation logic.
+	*
+	* @param value - Value to validate (usually masked string)
+	* @returns true if valid, false otherwise
+	*/
+	validate(value) {
+		if (value == null) return false;
+		const length = value.length;
+		if (this.minLength !== void 0 && length < this.minLength) return false;
+		if (this.maxLength !== void 0 && length > this.maxLength) return false;
+		if (this.pattern && !this.pattern.test(value)) return false;
+		return true;
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/CpfValidator.ts
+var CpfValidator = class extends BaseValidator {
+	constructor() {
+		const length = CPF_PATTERN.length;
+		super({
+			minLength: length,
+			maxLength: length
+		});
+	}
+	validate(value) {
+		if (value == null) return false;
+		return isCpfValid(value);
+	}
+};
+/**
+* Validates if a CPF (Brazilian tax ID) is valid.
+*
+* This function:
+* - Removes any non-digit characters (dots, dashes, spaces).
+* - Checks if CPF has 11 digits.
+* - Rejects CPFs where all digits are the same (e.g., '11111111111').
+* - Performs CPF check digit validation (standard algorithm).
+*
+* @param inputCPF - CPF as a string, can be formatted (e.g., "123.456.789-09").
+* @returns true if CPF is valid, false otherwise.
+*/
+function isCpfValid(inputCPF) {
+	const cpfOnlyNumbers = inputCPF.replace(/[\s.-]/g, "");
+	if (cpfOnlyNumbers.length !== 11) return false;
+	if (/^(\d)\1{10}$/.test(cpfOnlyNumbers)) return false;
+	let sum = 0;
+	for (let i = 0; i < 9; i++) sum += parseInt(cpfOnlyNumbers.charAt(i)) * (10 - i);
+	let firstCheckDigit = sum * 10 % 11;
+	if (firstCheckDigit === 10 || firstCheckDigit === 11) firstCheckDigit = 0;
+	if (firstCheckDigit !== parseInt(cpfOnlyNumbers.charAt(9))) return false;
+	sum = 0;
+	for (let i = 0; i < 10; i++) sum += parseInt(cpfOnlyNumbers.charAt(i)) * (11 - i);
+	let secondCheckDigit = sum * 10 % 11;
+	if (secondCheckDigit === 10 || secondCheckDigit === 11) secondCheckDigit = 0;
+	if (secondCheckDigit !== parseInt(cpfOnlyNumbers.charAt(10))) return false;
+	return true;
+}
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/CnpjValidator.ts
+var CnpjValidator = class extends BaseValidator {
+	constructor() {
+		const length = CNPJ_PATTERN.length;
+		super({
+			minLength: length,
+			maxLength: length
+		});
+	}
+	validate(value) {
+		if (value == null) return false;
+		return isCnpjValid(value);
+	}
+};
+/**
+* Validates whether a given CNPJ number is valid.
+* @param cnpj The CNPJ number as a string.
+* @returns True if valid, false otherwise.
+*/
+function isCnpjValid(cnpj) {
+	if (!cnpj) return false;
+	const cleanedCnpj = cnpj.replace(/[^\d]+/g, "");
+	if (cleanedCnpj.length !== 14) return false;
+	if (/^(\d)\1{13}$/.test(cleanedCnpj)) return false;
+	const baseCnpj = cleanedCnpj.slice(0, 12);
+	const checkDigits = cleanedCnpj.slice(12);
+	const firstCheckDigit = calculateCnpjCheckDigit(calculateCnpjWeightedSum(baseCnpj, 12, 5));
+	if (firstCheckDigit !== Number(checkDigits.charAt(0))) return false;
+	if (calculateCnpjCheckDigit(calculateCnpjWeightedSum(baseCnpj + firstCheckDigit, 13, 6)) !== Number(checkDigits.charAt(1))) return false;
+	return true;
+}
+/**
+* Calculates the weighted sum for CNPJ verification digits.
+* @param numbers The numeric string of the CNPJ.
+* @param size The number of digits to consider for the calculation.
+* @param position The starting multiplier position (5 or 6).
+* @returns The weighted sum.
+*/
+function calculateCnpjWeightedSum(numbers, size, position) {
+	let sum = 0;
+	for (let i = 0; i < size; i++) {
+		sum += Number(numbers.charAt(i)) * position;
+		position--;
+		if (position < 2) position = 9;
+	}
+	return sum;
+}
+/**
+* Calculates the verification digit based on the weighted sum.
+* @param sum The weighted sum.
+* @returns The verification digit (0-9).
+*/
+function calculateCnpjCheckDigit(sum) {
+	const remainder = sum % 11;
+	return remainder < 2 ? 0 : 11 - remainder;
+}
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/DateValidator.ts
+/**
+* Validator for dates in the format dd/mm/yyyy.
+*
+* Ensures the format is correct and the date is valid in the calendar (e.g. 30/02 is invalid).
+*/
+var DateValidator = class extends BaseValidator {
+	constructor() {
+		super({
+			minLength: 10,
+			maxLength: 10,
+			pattern: /^\d{2}\/\d{2}\/\d{4}$/
+		});
+	}
+	validate(value) {
+		if (!super.validate(value)) return false;
+		const [dayStr, monthStr, yearStr] = value.split("/");
+		const day = parseInt(dayStr, 10);
+		const month = parseInt(monthStr, 10);
+		const year = parseInt(yearStr, 10);
+		const date = new Date(year, month - 1, day);
+		return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day;
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/PhoneValidator.ts
+/**
+* Validates a Brazilian phone number with optional mobile or landline support.
+*/
+var PhoneValidator = class extends BaseValidator {
+	allowedDDDs;
+	constructor({ allowMobile = true, allowLandline = true, allowedDDDs = Array.from({ length: 89 }, (_, i) => `${i + 11}`), minLength, maxLength } = {}) {
+		super({
+			pattern: allowMobile && allowLandline ? /^\(?\d{2}\)?\s?(\d{4,5})-?\d{4}$/ : allowMobile ? /^\(?(\d{2})\)?\s?\d{5}-?\d{4}$/ : /^\(?(\d{2})\)?\s?\d{4}-?\d{4}$/,
+			minLength,
+			maxLength
+		});
+		this.allowedDDDs = allowedDDDs;
+	}
+	validate(value) {
+		if (!super.validate(value)) return false;
+		const digits = value.replace(/\D/g, "");
+		if (digits.length !== 10 && digits.length !== 11) return false;
+		const ddd = digits.slice(0, 2);
+		return this.allowedDDDs.includes(ddd);
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/FloatValidator.ts
+var FloatValidator = class extends BaseValidator {
+	constructor(maxDecimalPlaces = 3, minLength = 1, maxLength = 20) {
+		const decimalRegex = /* @__PURE__ */ new RegExp(`^\\d+(,\\d{1,${maxDecimalPlaces}})?$`);
+		super({
+			pattern: decimalRegex,
+			minLength,
+			maxLength
+		});
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/MoneyValidator.ts
+/**
+* Validates formatted currency strings.
+*
+* Supports optional prefix, negative values, and comma decimal separator.
+*/
+var MoneyValidator = class extends BaseValidator {
+	constructor({ prefix = "R$", maxDecimalPlaces = 2, allowNegative = true, minLength, maxLength } = {}) {
+		const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const pattern = /* @__PURE__ */ new RegExp(`^${escapedPrefix}\\s?${allowNegative ? "-?" : ""}\\d{1,3}(\\.\\d{3})*(,\\d{1,${maxDecimalPlaces}})?$`);
+		super({
+			pattern,
+			minLength,
+			maxLength
+		});
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/IntegerValidator.ts
+var IntegerValidator = class extends BaseValidator {
+	constructor(minLength = 1, maxLength = 15) {
+		super({
+			pattern: /^\d+$/,
+			minLength,
+			maxLength
+		});
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/ZipCodeValidator.ts
+var ZipCodeValidator = class extends BaseValidator {
+	constructor() {
+		const length = ZIP_CODE_PATTERN.length;
+		super({
+			minLength: length,
+			maxLength: length
+		});
+	}
+	validate(value) {
+		if (value == null) return false;
+		if (this.minLength !== void 0 && value.length < this.minLength) return false;
+		if (this.maxLength !== void 0 && value.length > this.maxLength) return false;
+		return true;
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/DocumentValidator.ts
+var DocumentValidator = class extends BaseValidator {
+	cpfValidator = new CpfValidator();
+	cnpjValidator = new CnpjValidator();
+	mode;
+	constructor(mode = DocumentMode.AUTO) {
+		super();
+		this.mode = mode;
+	}
+	validate(value) {
+		const digits = onlyDigits(value);
+		const type = this.resolveType(digits);
+		if (type === DocumentMode.CPF) return this.cpfValidator.validate(value);
+		if (type === DocumentMode.CNPJ) return this.cnpjValidator.validate(value);
+		return false;
+	}
+	resolveType(digits) {
+		if (this.mode === DocumentMode.CPF) return DocumentMode.CPF;
+		if (this.mode === DocumentMode.CNPJ) return DocumentMode.CNPJ;
+		return digits.length <= 11 ? DocumentMode.CPF : DocumentMode.CNPJ;
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/validators/NumericSymbolValidator.ts
+var NumericSymbolValidator = class extends BaseValidator {
+	constructor(minLength = 1, maxLength = 25) {
+		super({
+			pattern: /^[\d.,/-]+$/,
+			minLength,
+			maxLength
+		});
+	}
+};
+
+//#endregion
+//#region src/services/MaskModule/locales/br/registerMasks.ts
+function registerBrMasks() {
+	MaskModule.registerMask(Locale.BR, MaskType.CPF, new CpfMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.CPF, new CpfValidator());
+	MaskModule.registerMask(Locale.BR, MaskType.CNPJ, new CnpjMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.CNPJ, new CnpjValidator());
+	MaskModule.registerMask(Locale.BR, MaskType.DOCUMENT, new DocumentMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.DOCUMENT, new DocumentValidator());
+	MaskModule.registerMask(Locale.BR, MaskType.PHONE, new PhoneMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.PHONE, new PhoneValidator());
+	MaskModule.registerMask(Locale.BR, MaskType.DATE, new DateMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.DATE, new DateValidator());
+	MaskModule.registerMask(Locale.BR, MaskType.FLOAT, new FloatMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.FLOAT, new FloatValidator());
+	MaskModule.registerMask(Locale.BR, MaskType.INTEGER, new IntegerMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.INTEGER, new IntegerValidator());
+	MaskModule.registerMask(Locale.BR, MaskType.MONEY, new MoneyMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.MONEY, new MoneyValidator());
+	MaskModule.registerMask(Locale.BR, MaskType.NUMERIC_SYMBOL, new NumericSymbolMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.NUMERIC_SYMBOL, new NumericSymbolValidator());
+	MaskModule.registerMask(Locale.BR, MaskType.ZIP_CODE, new ZipCodeMask());
+	MaskModule.registerValidator(Locale.BR, MaskType.ZIP_CODE, new ZipCodeValidator());
+}
+
+//#endregion
+//#region src/services/MaskModule/index.ts
+registerBrMasks();
+
+//#endregion
+export { Locale, MaskModule, MaskType };
+//# sourceMappingURL=mask-modules.js.map