utilitify-core 1.0.0

package/dist/chunk-5WP7DWCG.js

@@ -0,0 +1,1285 @@
+import { getPhoneFormat, PHONE_FORMATS } from './chunk-GFDMZDMI.js';
+import { init_constants, DISPOSABLE_EMAIL_DOMAINS, FREE_EMAIL_DOMAINS, RESERVED_USERNAMES } from './chunk-ETWGPOPY.js';
+
+// src/validators/email.ts
+init_constants();
+var EMAIL_REGEX = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)])$/i;
+var SIMPLE_EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var DEFAULT_OPTIONS = {
+  checkDisposable: true,
+  checkCorporate: false
+};
+function validateEmail(email, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const errors = [];
+  const trimmedEmail = email?.trim() ?? "";
+  if (!trimmedEmail) {
+    errors.push({
+      field: "email",
+      code: "REQUIRED",
+      message: "Email is required"
+    });
+    return createResult(false, errors, "", "", "");
+  }
+  if (email.length > 320) {
+    errors.push({
+      field: "email",
+      code: "INVALID_LENGTH",
+      message: "Email must be between 1 and 320 characters"
+    });
+    return createResult(false, errors, "", "", "");
+  }
+  const normalizedEmail = trimmedEmail.toLowerCase();
+  const atIndex = normalizedEmail.lastIndexOf("@");
+  const localPart = atIndex > 0 ? normalizedEmail.slice(0, atIndex) : "";
+  const domain = atIndex > 0 ? normalizedEmail.slice(atIndex + 1) : "";
+  if (trimmedEmail.length > 254) {
+    errors.push({
+      field: "email",
+      code: "TOO_LONG",
+      message: "Email must not exceed 254 characters"
+    });
+  }
+  if (!EMAIL_REGEX.test(normalizedEmail)) {
+    errors.push({
+      field: "email",
+      code: "INVALID_FORMAT",
+      message: "Email format is invalid"
+    });
+    return createResult(false, errors, normalizedEmail, localPart, domain);
+  }
+  if (localPart.length > 64) {
+    errors.push({
+      field: "email",
+      code: "LOCAL_PART_TOO_LONG",
+      message: "Local part must not exceed 64 characters"
+    });
+  }
+  const isDisposable = DISPOSABLE_EMAIL_DOMAINS.has(domain);
+  if (opts.checkDisposable && isDisposable) {
+    errors.push({
+      field: "email",
+      code: "DISPOSABLE_EMAIL",
+      message: "Disposable email addresses are not allowed"
+    });
+  }
+  if (opts.blockedDomains?.includes(domain)) {
+    errors.push({
+      field: "email",
+      code: "BLOCKED_DOMAIN",
+      message: "This email domain is not allowed"
+    });
+  }
+  if (opts.allowedDomains && opts.allowedDomains.length > 0) {
+    if (!opts.allowedDomains.includes(domain)) {
+      errors.push({
+        field: "email",
+        code: "DOMAIN_NOT_ALLOWED",
+        message: "This email domain is not in the allowed list"
+      });
+    }
+  }
+  const isCorporate = !FREE_EMAIL_DOMAINS.has(domain) && !isDisposable;
+  return {
+    isValid: errors.length === 0,
+    errors,
+    isDisposable,
+    isCorporate,
+    normalized: normalizeEmail(normalizedEmail),
+    domain,
+    localPart
+  };
+}
+function isValidEmail(email) {
+  if (!email || typeof email !== "string") return false;
+  const trimmed = email.trim();
+  return SIMPLE_EMAIL_REGEX.test(trimmed) && EMAIL_REGEX.test(trimmed.toLowerCase());
+}
+function isDisposableEmail(email) {
+  if (!email || typeof email !== "string") return false;
+  const domain = email.trim().toLowerCase().split("@")[1];
+  return domain ? DISPOSABLE_EMAIL_DOMAINS.has(domain) : false;
+}
+function normalizeEmail(email) {
+  if (!email || typeof email !== "string") return "";
+  const trimmed = email.trim().toLowerCase();
+  const [localPart, domain] = trimmed.split("@");
+  if (!localPart || !domain) return trimmed;
+  let normalizedLocal = localPart;
+  const plusIndex = normalizedLocal.indexOf("+");
+  if (plusIndex > 0) {
+    normalizedLocal = normalizedLocal.slice(0, plusIndex);
+  }
+  if (domain === "gmail.com" || domain === "googlemail.com") {
+    normalizedLocal = normalizedLocal.replace(/\./g, "");
+  }
+  return `${normalizedLocal}@${domain}`;
+}
+function getEmailDomain(email) {
+  if (!email || typeof email !== "string") return "";
+  const parts = email.trim().toLowerCase().split("@");
+  return parts[1] || "";
+}
+function createResult(isValid, errors, normalized, localPart, domain) {
+  return {
+    isValid,
+    errors,
+    isDisposable: domain ? DISPOSABLE_EMAIL_DOMAINS.has(domain) : false,
+    isCorporate: domain ? !FREE_EMAIL_DOMAINS.has(domain) : false,
+    normalized,
+    domain,
+    localPart
+  };
+}
+
+// src/validators/name.ts
+var SCRIPT_PATTERNS = {
+  latin: /[\u0041-\u005A\u0061-\u007A\u00C0-\u00FF\u0100-\u017F\u0180-\u024F]/,
+  arabic: /[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]/,
+  cjk: /[\u4E00-\u9FFF\u3400-\u4DBF\u3040-\u309F\u30A0-\u30FF\uAC00-\uD7AF]/,
+  cyrillic: /[\u0400-\u04FF\u0500-\u052F]/,
+  devanagari: /[\u0900-\u097F]/
+};
+var ALLOWED_NAME_CHARS = /^[\p{L}\p{M}'\-\s.]+$/u;
+var DEFAULT_OPTIONS2 = {
+  minLength: 2,
+  maxLength: 100,
+  allowSpecialChars: true,
+  allowNumbers: false,
+  allowedScripts: ["latin", "arabic", "cjk", "cyrillic", "devanagari"]
+};
+function validateName(name, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const errors = [];
+  const sanitized = sanitizeName(name);
+  const detectedScript = detectScript(sanitized);
+  if (!name || !sanitized) {
+    errors.push({
+      field: "name",
+      code: "REQUIRED",
+      message: opts.messages?.required || "Name is required"
+    });
+    return { isValid: false, errors, sanitized: "", detectedScript: "unknown" };
+  }
+  if (sanitized.length < (opts.minLength ?? 2)) {
+    errors.push({
+      field: "name",
+      code: "TOO_SHORT",
+      message: opts.messages?.tooShort || `Name must be at least ${opts.minLength} characters`
+    });
+  }
+  if (sanitized.length > (opts.maxLength ?? 100)) {
+    errors.push({
+      field: "name",
+      code: "TOO_LONG",
+      message: opts.messages?.tooLong || `Name must not exceed ${opts.maxLength} characters`
+    });
+  }
+  if (!opts.allowNumbers && /\d/.test(sanitized)) {
+    errors.push({
+      field: "name",
+      code: "CONTAINS_NUMBERS",
+      message: opts.messages?.containsNumbers || "Name cannot contain numbers"
+    });
+  }
+  if (!opts.allowSpecialChars) {
+    if (!/^[\p{L}\p{M}\s'-]+$/u.test(sanitized)) {
+      errors.push({
+        field: "name",
+        code: "INVALID_CHARACTERS",
+        message: opts.messages?.invalidChars || "Name contains invalid characters"
+      });
+    }
+  } else {
+    if (!ALLOWED_NAME_CHARS.test(sanitized)) {
+      errors.push({
+        field: "name",
+        code: "INVALID_CHARACTERS",
+        message: opts.messages?.invalidChars || "Name contains invalid characters"
+      });
+    }
+  }
+  if (opts.allowedScripts && opts.allowedScripts.length > 0 && detectedScript !== "mixed") {
+    if (detectedScript !== "unknown" && !opts.allowedScripts.includes(detectedScript)) {
+      errors.push({
+        field: "name",
+        code: "SCRIPT_NOT_ALLOWED",
+        message: opts.messages?.scriptNotAllowed || `Script '${detectedScript}' is not allowed`
+      });
+    }
+  }
+  if (/^(.)\1+$/.test(sanitized.replace(/\s/g, ""))) {
+    errors.push({
+      field: "name",
+      code: "SUSPICIOUS_PATTERN",
+      message: opts.messages?.suspicious || "Name appears to be invalid"
+    });
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    sanitized,
+    detectedScript
+  };
+}
+function isValidName(name) {
+  if (!name || typeof name !== "string") return false;
+  const sanitized = sanitizeName(name);
+  return sanitized.length >= 2 && sanitized.length <= 100 && ALLOWED_NAME_CHARS.test(sanitized);
+}
+function sanitizeName(name) {
+  if (!name || typeof name !== "string") return "";
+  return name.normalize("NFC").trim().replace(/\s+/g, " ").replace(/[\x00-\x1F\x7F]/g, "");
+}
+function detectScript(text) {
+  if (!text) return "unknown";
+  const scripts = [];
+  for (const [script, pattern] of Object.entries(SCRIPT_PATTERNS)) {
+    if (pattern.test(text)) {
+      scripts.push(script);
+    }
+  }
+  if (scripts.length === 0) return "unknown";
+  if (scripts.length === 1)
+    return scripts[0];
+  return "mixed";
+}
+function formatName(name) {
+  if (!name || typeof name !== "string") return "";
+  return sanitizeName(name).split(" ").map((part) => {
+    if (part.length === 0) return "";
+    if (part.includes("-")) {
+      return part.split("-").map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join("-");
+    }
+    if (part.includes("'")) {
+      return part.split("'").map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join("'");
+    }
+    return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+  }).join(" ");
+}
+function splitName(fullName) {
+  const sanitized = sanitizeName(fullName);
+  const parts = sanitized.split(" ").filter(Boolean);
+  if (parts.length === 0) {
+    return { firstName: "", lastName: "" };
+  }
+  if (parts.length === 1) {
+    return { firstName: parts[0], lastName: "" };
+  }
+  if (parts.length === 2) {
+    return { firstName: parts[0], lastName: parts[1] };
+  }
+  return {
+    firstName: parts[0],
+    middleName: parts.slice(1, -1).join(" "),
+    lastName: parts[parts.length - 1]
+  };
+}
+
+// src/validators/phone.ts
+var DEFAULT_OPTIONS3 = {
+  strict: false,
+  mobileOnly: false
+};
+function validatePhone(phone, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS3, ...options };
+  const errors = [];
+  if (phone && phone.length > 50) {
+    errors.push({
+      field: "phone",
+      code: "INVALID_LENGTH",
+      message: "Phone number is too long"
+    });
+    return createEmptyResult(errors);
+  }
+  const cleaned = cleanPhoneNumber(phone);
+  if (!phone || !cleaned) {
+    errors.push({
+      field: "phone",
+      code: "REQUIRED",
+      message: opts.messages?.required || "Phone number is required"
+    });
+    return createEmptyResult(errors);
+  }
+  let detectedCountry = opts.countryCode?.toUpperCase() || "";
+  let nationalNumber = cleaned;
+  let dialCode = "";
+  if (cleaned.startsWith("+") || phone.startsWith("+")) {
+    const detection = detectCountryFromPhone(cleaned);
+    if (detection) {
+      detectedCountry = detection.countryCode;
+      nationalNumber = detection.nationalNumber;
+      dialCode = detection.dialCode;
+    }
+  }
+  const format = detectedCountry ? getPhoneFormat(detectedCountry) : null;
+  if (!format && opts.countryCode) {
+    errors.push({
+      field: "phone",
+      code: "UNSUPPORTED_COUNTRY",
+      message: opts.messages?.unsupportedCountry || `Country '${opts.countryCode}' is not supported`
+    });
+    return createEmptyResult(errors);
+  }
+  if (format) {
+    dialCode = format.dialCode;
+    const validLengths = format.lengths;
+    const dialCodeDigits = format.dialCode.replace(/\D/g, "");
+    if (nationalNumber.startsWith(dialCodeDigits)) {
+      nationalNumber = nationalNumber.slice(dialCodeDigits.length);
+    }
+    if (nationalNumber.startsWith("0")) {
+      nationalNumber = nationalNumber.slice(1);
+    }
+    if (!validLengths.includes(nationalNumber.length)) {
+      errors.push({
+        field: "phone",
+        code: "INVALID_LENGTH",
+        message: opts.messages?.invalidLength || `Phone number must be ${validLengths.join(" or ")} digits for ${detectedCountry}`
+      });
+    }
+    const phoneType = determinePhoneType(nationalNumber, format);
+    if (opts.mobileOnly && phoneType !== "mobile") {
+      errors.push({
+        field: "phone",
+        code: "MOBILE_ONLY",
+        message: opts.messages?.mobileOnly || "Only mobile numbers are allowed"
+      });
+    }
+    return {
+      isValid: errors.length === 0,
+      errors,
+      countryCode: detectedCountry,
+      nationalNumber,
+      formatted: {
+        national: formatNational(nationalNumber, format),
+        international: formatInternational(nationalNumber, format),
+        e164: formatE164(nationalNumber, format)
+      },
+      type: phoneType
+    };
+  }
+  if (nationalNumber.length < 7 || nationalNumber.length > 15) {
+    errors.push({
+      field: "phone",
+      code: "INVALID_LENGTH",
+      message: opts.messages?.invalidLength || "Phone number length is invalid"
+    });
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    countryCode: detectedCountry,
+    nationalNumber,
+    formatted: {
+      national: nationalNumber,
+      international: dialCode ? `${dialCode} ${nationalNumber}` : nationalNumber,
+      e164: dialCode ? `${dialCode}${nationalNumber}` : `+${nationalNumber}`
+    },
+    type: "unknown"
+  };
+}
+function isValidPhone(phone, countryCode) {
+  const result = validatePhone(phone, { countryCode });
+  return result.isValid;
+}
+function formatPhone(phone, format = "international", countryCode) {
+  const result = validatePhone(phone, { countryCode });
+  if (!result.isValid) return phone;
+  return result.formatted[format];
+}
+function cleanPhoneNumber(phone) {
+  if (!phone || typeof phone !== "string") return "";
+  const trimmed = phone.trim();
+  const hasPlus = trimmed.startsWith("+");
+  const digits = trimmed.replace(/\D/g, "");
+  return hasPlus ? `+${digits}` : digits;
+}
+function detectCountryFromPhone(phone) {
+  const digits = phone.replace(/\D/g, "");
+  if (digits.startsWith("1") && digits.length >= 4) {
+    const areaCode = digits.slice(1, 4);
+    const nationalNumber = digits.slice(1);
+    for (const format of Object.values(PHONE_FORMATS)) {
+      if (format.dialCode === "+1" && format.areaCodes?.includes(areaCode)) {
+        return {
+          countryCode: format.countryCode,
+          nationalNumber,
+          dialCode: "+1"
+        };
+      }
+    }
+    return {
+      countryCode: "US",
+      nationalNumber,
+      dialCode: "+1"
+    };
+  }
+  const sortedFormats = Object.values(PHONE_FORMATS).sort(
+    (a, b) => b.dialCode.replace(/\D/g, "").length - a.dialCode.replace(/\D/g, "").length
+  );
+  for (const format of sortedFormats) {
+    const dialDigits = format.dialCode.replace(/\D/g, "");
+    if (format.dialCode === "+1") continue;
+    if (digits.startsWith(dialDigits)) {
+      return {
+        countryCode: format.countryCode,
+        nationalNumber: digits.slice(dialDigits.length),
+        dialCode: format.dialCode
+      };
+    }
+  }
+  return null;
+}
+function determinePhoneType(nationalNumber, format) {
+  for (const prefix of format.mobilePrefixes) {
+    if (nationalNumber.startsWith(prefix)) {
+      return "mobile";
+    }
+  }
+  for (const prefix of format.landlinePrefixes) {
+    if (nationalNumber.startsWith(prefix)) {
+      return "landline";
+    }
+  }
+  if (format.mobilePrefixes.length === 0 && format.landlinePrefixes.length === 0) {
+    return "unknown";
+  }
+  return "unknown";
+}
+function formatNational(nationalNumber, format) {
+  return applyPattern(nationalNumber, format.pattern);
+}
+function formatInternational(nationalNumber, format) {
+  return `${format.dialCode} ${applyPattern(nationalNumber, format.pattern)}`;
+}
+function formatE164(nationalNumber, format) {
+  return `${format.dialCode}${nationalNumber}`;
+}
+function applyPattern(number, pattern) {
+  let result = "";
+  let numberIndex = 0;
+  for (const char of pattern) {
+    if (char === "X") {
+      if (numberIndex < number.length) {
+        result += number[numberIndex];
+        numberIndex++;
+      }
+    } else {
+      result += char;
+    }
+  }
+  if (numberIndex < number.length) {
+    result += number.slice(numberIndex);
+  }
+  return result.trim();
+}
+function createEmptyResult(errors) {
+  return {
+    isValid: false,
+    errors,
+    countryCode: "",
+    nationalNumber: "",
+    formatted: {
+      national: "",
+      international: "",
+      e164: ""
+    },
+    type: "unknown"
+  };
+}
+function getDialingCode(countryCode) {
+  const format = getPhoneFormat(countryCode);
+  return format?.dialCode || null;
+}
+function parsePhone(phone) {
+  const result = validatePhone(phone);
+  return {
+    countryCode: result.countryCode,
+    dialCode: getDialingCode(result.countryCode) || "",
+    nationalNumber: result.nationalNumber,
+    isValid: result.isValid
+  };
+}
+
+// src/validators/username.ts
+init_constants();
+var DEFAULT_USERNAME_PATTERN = /^[a-zA-Z0-9_\-.]+$/;
+var DEFAULT_OPTIONS4 = {
+  minLength: 3,
+  maxLength: 30,
+  allowedChars: DEFAULT_USERNAME_PATTERN,
+  reserved: [],
+  allowEmail: false
+};
+function validateUsername(username, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS4, ...options };
+  const errors = [];
+  const sanitized = username?.trim().toLowerCase() ?? "";
+  if (!username || !sanitized) {
+    errors.push({
+      field: "username",
+      code: "REQUIRED",
+      message: opts.messages?.required || "Username is required"
+    });
+    return { isValid: false, errors, sanitized: "", isReserved: false };
+  }
+  if (!opts.allowEmail && sanitized.includes("@")) {
+    errors.push({
+      field: "username",
+      code: "EMAIL_NOT_ALLOWED",
+      message: opts.messages?.emailNotAllowed || "Email addresses are not allowed as usernames"
+    });
+  }
+  if (sanitized.length < (opts.minLength ?? 3)) {
+    errors.push({
+      field: "username",
+      code: "TOO_SHORT",
+      message: opts.messages?.tooShort || `Username must be at least ${opts.minLength} characters`
+    });
+  }
+  if (sanitized.length > (opts.maxLength ?? 30)) {
+    errors.push({
+      field: "username",
+      code: "TOO_LONG",
+      message: opts.messages?.tooLong || `Username must not exceed ${opts.maxLength} characters`
+    });
+  }
+  const charPattern = opts.allowedChars ?? DEFAULT_USERNAME_PATTERN;
+  if (!charPattern.test(sanitized)) {
+    errors.push({
+      field: "username",
+      code: "INVALID_CHARACTERS",
+      message: opts.messages?.invalidChars || "Username can only contain letters, numbers, underscores, hyphens, and periods"
+    });
+  }
+  if (/^[_\-.]|[_\-.]$/.test(sanitized)) {
+    errors.push({
+      field: "username",
+      code: "INVALID_START_END",
+      message: opts.messages?.invalidStartEnd || "Username cannot start or end with special characters"
+    });
+  }
+  if (/[_\-.]{2,}/.test(sanitized)) {
+    errors.push({
+      field: "username",
+      code: "CONSECUTIVE_SPECIAL",
+      message: opts.messages?.consecutiveSpecial || "Username cannot have consecutive special characters"
+    });
+  }
+  const allReserved = /* @__PURE__ */ new Set([...RESERVED_USERNAMES, ...opts.reserved ?? []]);
+  const isReserved = allReserved.has(sanitized);
+  if (isReserved) {
+    errors.push({
+      field: "username",
+      code: "RESERVED",
+      message: opts.messages?.reserved || "This username is reserved"
+    });
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    sanitized,
+    isReserved
+  };
+}
+function isValidUsername(username) {
+  if (!username || typeof username !== "string") return false;
+  const trimmed = username.trim().toLowerCase();
+  return trimmed.length >= 3 && trimmed.length <= 30 && DEFAULT_USERNAME_PATTERN.test(trimmed) && !/^[_\-.]|[_\-.]$/.test(trimmed) && !/[_\-.]{2,}/.test(trimmed) && !RESERVED_USERNAMES.has(trimmed);
+}
+function isReservedUsername(username, additionalReserved = []) {
+  if (!username || typeof username !== "string") return false;
+  const normalized = username.trim().toLowerCase();
+  const allReserved = /* @__PURE__ */ new Set([...RESERVED_USERNAMES, ...additionalReserved]);
+  return allReserved.has(normalized);
+}
+function sanitizeUsername(username) {
+  if (!username || typeof username !== "string") return "";
+  return username.trim().toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_\-.]/g, "").replace(/[_\-.]+/g, (match) => match[0]).replace(/^[_\-.]|[_\-.]$/g, "");
+}
+function suggestUsernames(base, count = 5) {
+  if (!base || typeof base !== "string") return [];
+  let baseUsername = base.includes("@") ? base.split("@")[0] : base;
+  baseUsername = sanitizeUsername(baseUsername);
+  if (!baseUsername) return [];
+  const suggestions = [baseUsername];
+  for (let i = 1; suggestions.length < count; i++) {
+    suggestions.push(`${baseUsername}${i}`);
+  }
+  const randomSuffix = Math.floor(Math.random() * 1e3);
+  suggestions.push(`${baseUsername}_${randomSuffix}`);
+  return suggestions.slice(0, count);
+}
+
+// src/validators/url.ts
+var DEFAULT_OPTIONS5 = {
+  requireHttps: false,
+  allowLocalhost: true,
+  allowIpAddress: true,
+  allowedProtocols: ["http:", "https:"]
+};
+var IPV4_REGEX = /^(\d{1,3}\.){3}\d{1,3}$/;
+var IPV6_REGEX = /^\[[\da-fA-F:]+\]$/;
+function validateUrl(url, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS5, ...options };
+  const errors = [];
+  if (url && url.length > 4096) {
+    errors.push({
+      field: "url",
+      code: "INVALID_LENGTH",
+      message: "URL is too long"
+    });
+    return createEmptyResult2(errors);
+  }
+  const trimmed = url?.trim() ?? "";
+  if (!trimmed) {
+    errors.push({
+      field: "url",
+      code: "REQUIRED",
+      message: opts.messages?.required || "URL is required"
+    });
+    return createEmptyResult2(errors);
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    errors.push({
+      field: "url",
+      code: "INVALID_FORMAT",
+      message: opts.messages?.invalidFormat || "URL format is invalid"
+    });
+    return createEmptyResult2(errors);
+  }
+  const allowedProtocols = opts.allowedProtocols || ["http:", "https:"];
+  if (!allowedProtocols.includes(parsed.protocol)) {
+    errors.push({
+      field: "url",
+      code: "INVALID_PROTOCOL",
+      message: opts.messages?.invalidProtocol || `Protocol must be one of: ${allowedProtocols.join(", ")}`
+    });
+  }
+  if (opts.requireHttps && parsed.protocol !== "https:") {
+    errors.push({
+      field: "url",
+      code: "HTTPS_REQUIRED",
+      message: "HTTPS is required"
+    });
+  }
+  const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "::1" || parsed.hostname === "[::1]";
+  if (!opts.allowLocalhost && isLocalhost) {
+    errors.push({
+      field: "url",
+      code: "LOCALHOST_NOT_ALLOWED",
+      message: "Localhost URLs are not allowed"
+    });
+  }
+  const isIpAddress = IPV4_REGEX.test(parsed.hostname) || IPV6_REGEX.test(parsed.hostname);
+  if (!opts.allowIpAddress && isIpAddress && !isLocalhost) {
+    errors.push({
+      field: "url",
+      code: "IP_ADDRESS_NOT_ALLOWED",
+      message: "IP address URLs are not allowed"
+    });
+  }
+  if (opts.blockedDomains?.includes(parsed.hostname.toLowerCase())) {
+    errors.push({
+      field: "url",
+      code: "BLOCKED_DOMAIN",
+      message: opts.messages?.blockedDomain || "This domain is not allowed"
+    });
+  }
+  if (opts.allowedTlds && opts.allowedTlds.length > 0 && !isIpAddress && !isLocalhost) {
+    const parts = parsed.hostname.split(".");
+    const tld = parts[parts.length - 1]?.toLowerCase();
+    if (tld && !opts.allowedTlds.includes(tld)) {
+      errors.push({
+        field: "url",
+        code: "INVALID_TLD",
+        message: opts.messages?.invalidTld || `TLD must be one of: ${opts.allowedTlds.join(", ")}`
+      });
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    parsed: {
+      protocol: parsed.protocol,
+      hostname: parsed.hostname,
+      port: parsed.port,
+      pathname: parsed.pathname,
+      search: parsed.search,
+      hash: parsed.hash
+    },
+    normalized: parsed.href
+  };
+}
+function isValidUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  try {
+    const parsed = new URL(url.trim());
+    return ["http:", "https:"].includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+function isHttpsUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  try {
+    const parsed = new URL(url.trim());
+    return parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function getUrlDomain(url) {
+  if (!url || typeof url !== "string") return "";
+  try {
+    const parsed = new URL(url.trim());
+    return parsed.hostname;
+  } catch {
+    return "";
+  }
+}
+function normalizeUrl(url) {
+  if (!url || typeof url !== "string") return "";
+  try {
+    const parsed = new URL(url.trim());
+    if (parsed.pathname !== "/" && parsed.pathname.endsWith("/")) {
+      parsed.pathname = parsed.pathname.slice(0, -1);
+    }
+    return parsed.href;
+  } catch {
+    return "";
+  }
+}
+function isDataUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  return url.trim().toLowerCase().startsWith("data:");
+}
+function isDangerousUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  const dangerous = ["javascript:", "vbscript:", "data:"];
+  const trimmed = url.trim().toLowerCase();
+  return dangerous.some((scheme) => trimmed.startsWith(scheme));
+}
+function createEmptyResult2(errors) {
+  return {
+    isValid: false,
+    errors,
+    normalized: ""
+  };
+}
+
+// src/validators/creditCard.ts
+var CARD_PATTERNS = {
+  visa: /^4[0-9]{12}(?:[0-9]{3})?$/,
+  mastercard: /^5[1-5][0-9]{14}$|^2(?:2(?:2[1-9]|[3-9][0-9])|[3-6][0-9][0-9]|7(?:[01][0-9]|20))[0-9]{12}$/,
+  amex: /^3[47][0-9]{13}$/,
+  discover: /^6(?:011|5[0-9]{2})[0-9]{12}$/,
+  diners: /^3(?:0[0-5]|[68][0-9])[0-9]{11}$/,
+  jcb: /^(?:2131|1800|35\d{3})\d{11}$/,
+  unionpay: /^62[0-9]{14,17}$/,
+  maestro: /^(?:5[06789]|6)[0-9]{10,17}$/,
+  unknown: /^[0-9]{13,19}$/
+};
+var CARD_PREFIXES = {
+  "4": "visa",
+  "34": "amex",
+  "37": "amex",
+  "51": "mastercard",
+  "52": "mastercard",
+  "53": "mastercard",
+  "54": "mastercard",
+  "55": "mastercard",
+  "22": "mastercard",
+  "23": "mastercard",
+  "24": "mastercard",
+  "25": "mastercard",
+  "26": "mastercard",
+  "27": "mastercard",
+  "6011": "discover",
+  "65": "discover",
+  "30": "diners",
+  "36": "diners",
+  "38": "diners",
+  "35": "jcb",
+  "62": "unionpay"
+};
+var DEFAULT_OPTIONS6 = {
+  checkLuhn: true
+};
+function validateCreditCard(cardNumber, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS6, ...options };
+  const errors = [];
+  if (cardNumber && cardNumber.length > 50) {
+    errors.push({
+      field: "creditCard",
+      code: "INVALID_LENGTH",
+      message: "Credit card number is too long"
+    });
+    return createEmptyResult3(errors);
+  }
+  const cleaned = cleanCardNumber(cardNumber);
+  if (!cardNumber || !cleaned) {
+    errors.push({
+      field: "creditCard",
+      code: "REQUIRED",
+      message: opts.messages?.required || "Credit card number is required"
+    });
+    return createEmptyResult3(errors);
+  }
+  if (!/^[0-9]{13,19}$/.test(cleaned)) {
+    errors.push({
+      field: "creditCard",
+      code: "INVALID_FORMAT",
+      message: opts.messages?.invalidFormat || "Credit card number format is invalid"
+    });
+    return createEmptyResult3(errors, cleaned);
+  }
+  const cardType = detectCardType(cleaned);
+  if (opts.checkLuhn && !luhnCheck(cleaned)) {
+    errors.push({
+      field: "creditCard",
+      code: "INVALID_LUHN",
+      message: opts.messages?.invalidLuhn || "Credit card number is invalid"
+    });
+  }
+  if (opts.allowedTypes && opts.allowedTypes.length > 0) {
+    if (!opts.allowedTypes.includes(cardType)) {
+      errors.push({
+        field: "creditCard",
+        code: "TYPE_NOT_ALLOWED",
+        message: opts.messages?.typeNotAllowed || `Card type '${cardType}' is not allowed`
+      });
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    cardType,
+    masked: maskCardNumber(cleaned),
+    cleaned
+  };
+}
+function isValidCreditCard(cardNumber) {
+  if (!cardNumber || typeof cardNumber !== "string") return false;
+  const cleaned = cleanCardNumber(cardNumber);
+  return /^[0-9]{13,19}$/.test(cleaned) && luhnCheck(cleaned);
+}
+function detectCardType(cardNumber) {
+  const cleaned = cleanCardNumber(cardNumber);
+  for (const [type, pattern] of Object.entries(CARD_PATTERNS)) {
+    if (type !== "unknown" && pattern.test(cleaned)) {
+      return type;
+    }
+  }
+  return "unknown";
+}
+function getCardTypeFromPrefix(cardNumber) {
+  const cleaned = cleanCardNumber(cardNumber);
+  if (cleaned.length < 1) return null;
+  const prefixes = Object.keys(CARD_PREFIXES).sort((a, b) => b.length - a.length);
+  for (const prefix of prefixes) {
+    if (cleaned.startsWith(prefix)) {
+      return CARD_PREFIXES[prefix];
+    }
+  }
+  return null;
+}
+function luhnCheck(cardNumber) {
+  const cleaned = cleanCardNumber(cardNumber);
+  if (!cleaned || cleaned.length < 13) return false;
+  let sum = 0;
+  let isEven = false;
+  for (let i = cleaned.length - 1; i >= 0; i--) {
+    let digit = parseInt(cleaned[i], 10);
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9) {
+        digit -= 9;
+      }
+    }
+    sum += digit;
+    isEven = !isEven;
+  }
+  return sum % 10 === 0;
+}
+function maskCardNumber(cardNumber, maskChar = "*") {
+  const cleaned = cleanCardNumber(cardNumber);
+  if (cleaned.length < 4) return cleaned;
+  const lastFour = cleaned.slice(-4);
+  const masked = maskChar.repeat(cleaned.length - 4);
+  return masked + lastFour;
+}
+function formatCardNumber(cardNumber) {
+  const cleaned = cleanCardNumber(cardNumber);
+  const type = detectCardType(cleaned);
+  if (type === "amex") {
+    return cleaned.replace(/(\d{4})(\d{6})(\d{5})/, "$1 $2 $3").trim();
+  }
+  return cleaned.replace(/(\d{4})(?=\d)/g, "$1 ").trim();
+}
+function isValidCVV(cvv, cardType) {
+  if (!cvv || typeof cvv !== "string") return false;
+  const cleaned = cvv.replace(/\D/g, "");
+  if (cardType === "amex") {
+    return /^\d{4}$/.test(cleaned);
+  }
+  return /^\d{3,4}$/.test(cleaned);
+}
+function isValidExpiry(month, year) {
+  const m = typeof month === "string" ? parseInt(month, 10) : month;
+  let y = typeof year === "string" ? parseInt(year, 10) : year;
+  if (y < 100) {
+    y += 2e3;
+  }
+  if (isNaN(m) || m < 1 || m > 12) return false;
+  if (isNaN(y) || y < 2e3) return false;
+  const now = /* @__PURE__ */ new Date();
+  const expiry = new Date(y, m, 0);
+  return expiry >= now;
+}
+function cleanCardNumber(cardNumber) {
+  if (!cardNumber || typeof cardNumber !== "string") return "";
+  return cardNumber.replace(/\D/g, "");
+}
+function createEmptyResult3(errors, cleaned = "") {
+  return {
+    isValid: false,
+    errors,
+    cardType: null,
+    masked: "",
+    cleaned
+  };
+}
+
+// src/validators/ip.ts
+var IPV4_REGEX2 = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+var IPV4_CIDR_REGEX = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\/([0-9]|[12][0-9]|3[0-2])$/;
+var IPV6_REGEX2 = /^(?:(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?::[0-9a-fA-F]{1,4}){1,6}|:(?::[0-9a-fA-F]{1,4}){1,7}|::(?:[fF]{4}:)?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)|(?:[0-9a-fA-F]{1,4}:){1,4}:(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))$/;
+var IPV6_CIDR_REGEX = /^(.+)\/([0-9]|[1-9][0-9]|1[01][0-9]|12[0-8])$/;
+var PRIVATE_IPV4_RANGES = [
+  /^10\./,
+  // 10.0.0.0/8
+  /^172\.(1[6-9]|2[0-9]|3[01])\./,
+  // 172.16.0.0/12
+  /^192\.168\./,
+  // 192.168.0.0/16
+  /^169\.254\./
+  // Link-local 169.254.0.0/16
+];
+var DEFAULT_OPTIONS7 = {
+  version: "both",
+  allowCidr: false,
+  allowPrivate: true
+};
+function validateIp(ip, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS7, ...options };
+  const errors = [];
+  const trimmed = ip?.trim() ?? "";
+  if (!ip || !trimmed) {
+    errors.push({
+      field: "ip",
+      code: "REQUIRED",
+      message: opts.messages?.required || "IP address is required"
+    });
+    return createEmptyResult4(errors);
+  }
+  let ipPart = trimmed;
+  let cidr = null;
+  if (trimmed.includes("/")) {
+    if (!opts.allowCidr) {
+      errors.push({
+        field: "ip",
+        code: "CIDR_NOT_ALLOWED",
+        message: "CIDR notation is not allowed"
+      });
+    }
+    const parts = trimmed.split("/");
+    ipPart = parts[0];
+    cidr = parseInt(parts[1], 10);
+  }
+  let version = null;
+  let isValid = false;
+  if (IPV4_REGEX2.test(ipPart)) {
+    version = 4;
+    isValid = true;
+    if (cidr !== null && (cidr < 0 || cidr > 32)) {
+      errors.push({
+        field: "ip",
+        code: "INVALID_CIDR",
+        message: "CIDR prefix must be 0-32 for IPv4"
+      });
+    }
+  } else if (IPV6_REGEX2.test(ipPart)) {
+    version = 6;
+    isValid = true;
+    if (cidr !== null && (cidr < 0 || cidr > 128)) {
+      errors.push({
+        field: "ip",
+        code: "INVALID_CIDR",
+        message: "CIDR prefix must be 0-128 for IPv6"
+      });
+    }
+  }
+  if (!isValid) {
+    errors.push({
+      field: "ip",
+      code: "INVALID_FORMAT",
+      message: opts.messages?.invalidFormat || "IP address format is invalid"
+    });
+    return createEmptyResult4(errors, trimmed);
+  }
+  if (opts.version !== "both" && version !== opts.version) {
+    errors.push({
+      field: "ip",
+      code: "VERSION_NOT_ALLOWED",
+      message: opts.messages?.versionNotAllowed || `IPv${version} is not allowed, expected IPv${opts.version}`
+    });
+  }
+  const isPrivate = isPrivateIp(ipPart, version ?? void 0);
+  const isLoopback = isLoopbackIp(ipPart, version ?? void 0);
+  if (!opts.allowPrivate && (isPrivate || isLoopback)) {
+    errors.push({
+      field: "ip",
+      code: "PRIVATE_NOT_ALLOWED",
+      message: opts.messages?.privateNotAllowed || "Private/local IP addresses are not allowed"
+    });
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    version,
+    isPrivate,
+    isLoopback,
+    cidr,
+    normalized: trimmed.toLowerCase()
+  };
+}
+function isValidIPv4(ip) {
+  if (!ip || typeof ip !== "string") return false;
+  return IPV4_REGEX2.test(ip.trim());
+}
+function isValidIPv6(ip) {
+  if (!ip || typeof ip !== "string") return false;
+  return IPV6_REGEX2.test(ip.trim());
+}
+function isValidIP(ip) {
+  return isValidIPv4(ip) || isValidIPv6(ip);
+}
+function isPrivateIp(ip, version) {
+  if (!ip) return false;
+  const v = version ?? (isValidIPv4(ip) ? 4 : isValidIPv6(ip) ? 6 : void 0);
+  if (v === 4) {
+    return PRIVATE_IPV4_RANGES.some((range) => range.test(ip));
+  }
+  if (v === 6) {
+    const lower = ip.toLowerCase();
+    return lower.startsWith("fc") || lower.startsWith("fd") || // fe80::/10 (Link-local)
+    lower.startsWith("fe80");
+  }
+  return false;
+}
+function isLoopbackIp(ip, version) {
+  if (!ip) return false;
+  const v = version ?? (isValidIPv4(ip) ? 4 : isValidIPv6(ip) ? 6 : void 0);
+  if (v === 4) {
+    return ip.startsWith("127.");
+  }
+  if (v === 6) {
+    const lower = ip.toLowerCase();
+    return lower === "::1" || lower === "0000:0000:0000:0000:0000:0000:0000:0001";
+  }
+  return false;
+}
+function getIpVersion(ip) {
+  if (isValidIPv4(ip)) return 4;
+  if (isValidIPv6(ip)) return 6;
+  return null;
+}
+function isValidCidr(cidr) {
+  if (!cidr || typeof cidr !== "string") return false;
+  if (IPV4_CIDR_REGEX.test(cidr)) return true;
+  const match = cidr.match(IPV6_CIDR_REGEX);
+  if (match) {
+    return IPV6_REGEX2.test(match[1]) && parseInt(match[2], 10) <= 128;
+  }
+  return false;
+}
+function createEmptyResult4(errors, normalized = "") {
+  return {
+    isValid: false,
+    errors,
+    version: null,
+    isPrivate: false,
+    isLoopback: false,
+    cidr: null,
+    normalized
+  };
+}
+
+// src/validators/financial.ts
+function validateIBAN(iban, options = {}) {
+  if (!iban || typeof iban !== "string") {
+    return { isValid: false, errors: [{ field: "iban", code: "REQUIRED", message: "IBAN is required" }] };
+  }
+  const cleanIban = iban.replace(/[\s]+/g, "").toUpperCase();
+  const errors = [];
+  if (iban.length > 50) {
+    errors.push({
+      field: "iban",
+      code: "INVALID_LENGTH",
+      message: "IBAN is too long"
+    });
+    return { isValid: false, errors };
+  }
+  if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleanIban)) {
+    errors.push({
+      field: "iban",
+      code: "INVALID_FORMAT",
+      message: options.messages?.invalidFormat || "Invalid IBAN format"
+    });
+    return { isValid: false, errors };
+  }
+  const lengths = {
+    AL: 28,
+    AD: 24,
+    AT: 20,
+    AZ: 28,
+    BH: 22,
+    BE: 16,
+    BA: 20,
+    BR: 29,
+    BG: 22,
+    CR: 21,
+    HR: 21,
+    CY: 28,
+    CZ: 24,
+    DK: 18,
+    DO: 28,
+    EE: 20,
+    FO: 18,
+    FI: 18,
+    FR: 27,
+    GE: 22,
+    DE: 22,
+    GI: 23,
+    GR: 27,
+    GL: 18,
+    GT: 28,
+    HU: 28,
+    IS: 26,
+    IE: 22,
+    IL: 23,
+    IT: 27,
+    JO: 30,
+    KZ: 20,
+    KW: 30,
+    LV: 21,
+    LB: 28,
+    LI: 21,
+    LT: 20,
+    LU: 20,
+    MK: 19,
+    MT: 31,
+    MR: 27,
+    MU: 30,
+    MC: 27,
+    MD: 24,
+    ME: 22,
+    NL: 18,
+    NO: 15,
+    PK: 24,
+    PS: 29,
+    PL: 28,
+    PT: 25,
+    QA: 29,
+    RO: 24,
+    LC: 32,
+    SM: 27,
+    ST: 25,
+    SA: 24,
+    RS: 22,
+    SC: 31,
+    SK: 24,
+    SI: 19,
+    ES: 24,
+    SE: 24,
+    CH: 21,
+    TN: 24,
+    TR: 26,
+    AE: 23,
+    GB: 22,
+    VG: 24
+  };
+  const countryCode = cleanIban.substring(0, 2);
+  const expectedLength = lengths[countryCode];
+  if (expectedLength && cleanIban.length !== expectedLength) {
+    errors.push({
+      field: "iban",
+      code: "INVALID_LENGTH",
+      message: options.messages?.invalidLength || `IBAN for ${countryCode} must be ${expectedLength} characters`
+    });
+    return { isValid: false, errors };
+  }
+  const rearranged = cleanIban.substring(4) + cleanIban.substring(0, 4);
+  const numeric = rearranged.replace(/[A-Z]/g, (char) => (char.charCodeAt(0) - 55).toString());
+  if (mod97(numeric) !== 1) {
+    errors.push({
+      field: "iban",
+      code: "INVALID_CHECKSUM",
+      message: options.messages?.invalidChecksum || "Invalid IBAN checksum"
+    });
+    return { isValid: false, errors };
+  }
+  return { isValid: true, errors: [] };
+}
+function validateVAT(vat, options = {}) {
+  if (!vat || typeof vat !== "string") {
+    return { isValid: false, errors: [{ field: "vat", code: "REQUIRED", message: "VAT number is required" }] };
+  }
+  const cleanVat = vat.replace(/[\s.-]+/g, "").toUpperCase();
+  const errors = [];
+  if (vat.length > 50) {
+    errors.push({
+      field: "vat",
+      code: "INVALID_LENGTH",
+      message: "VAT number is too long"
+    });
+    return { isValid: false, errors };
+  }
+  if (!/^[A-Z]{2}[A-Z0-9]{2,13}$/.test(cleanVat)) {
+    errors.push({
+      field: "vat",
+      code: "INVALID_FORMAT",
+      message: "Invalid VAT number format"
+    });
+    return { isValid: false, errors };
+  }
+  if (options.countryCode) {
+    const providedCode = options.countryCode.toUpperCase();
+    if (!cleanVat.startsWith(providedCode)) {
+      errors.push({
+        field: "vat",
+        code: "INVALID_COUNTRY",
+        message: `VAT number must start with ${providedCode}`
+      });
+      return { isValid: false, errors };
+    }
+  }
+  return { isValid: true, errors: [] };
+}
+function mod97(numericString) {
+  let remainder = 0;
+  for (let i = 0; i < numericString.length; i += 7) {
+    const chunk = (remainder ? remainder.toString() : "") + numericString.substring(i, i + 7);
+    remainder = parseInt(chunk, 10) % 97;
+  }
+  return remainder;
+}
+
+export { detectCardType, detectScript, formatCardNumber, formatName, formatPhone, getCardTypeFromPrefix, getEmailDomain, getIpVersion, getUrlDomain, isDangerousUrl, isDataUrl, isDisposableEmail, isHttpsUrl, isLoopbackIp, isPrivateIp, isReservedUsername, isValidCVV, isValidCidr, isValidCreditCard, isValidEmail, isValidExpiry, isValidIP, isValidIPv4, isValidIPv6, isValidName, isValidPhone, isValidUrl, isValidUsername, luhnCheck, maskCardNumber, normalizeEmail, normalizeUrl, parsePhone, sanitizeName, sanitizeUsername, splitName, suggestUsernames, validateCreditCard, validateEmail, validateIBAN, validateIp, validateName, validatePhone, validateUrl, validateUsername, validateVAT };
+//# sourceMappingURL=chunk-5WP7DWCG.js.map
+//# sourceMappingURL=chunk-5WP7DWCG.js.map