@gzl10/ts-helpers 4.2.1

package/dist/node/validation.js

@@ -0,0 +1,677 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/validation.ts
+var validation_exports = {};
+__export(validation_exports, {
+  escapeShellCommand: () => escapeShellCommand,
+  generateAlphaNumericString: () => generateAlphaNumericString,
+  generateAlphaString: () => generateAlphaString,
+  generateComplexString: () => generateComplexString,
+  generateEmail: () => generateEmail,
+  generateHexColor: () => generateHexColor,
+  generateNonce: () => generateNonce,
+  generatePassword: () => generatePassword,
+  generateRandomInteger: () => generateRandomInteger,
+  generateSecureToken: () => generateSecureToken,
+  generateSpanishCIF: () => generateSpanishCIF,
+  generateSpanishIBAN: () => generateSpanishIBAN,
+  generateSpanishNIE: () => generateSpanishNIE,
+  generateSpanishNIF: () => generateSpanishNIF,
+  generateSpanishPostalCode: () => generateSpanishPostalCode,
+  generateUsername: () => generateUsername,
+  generateUsernameFromEmail: () => generateUsernameFromEmail,
+  hashString: () => hashString,
+  isSecureUrl: () => isSecureUrl,
+  isValidBase64: () => isValidBase64,
+  isValidCIF: () => isValidCIF,
+  isValidDotNotationPath: () => isValidDotNotationPath,
+  isValidEmail: () => isValidEmail,
+  isValidJSON: () => isValidJSON,
+  isValidJWTFormat: () => isValidJWTFormat,
+  isValidNIE: () => isValidNIE,
+  isValidNIF: () => isValidNIF,
+  isValidSpanishIBAN: () => isValidSpanishIBAN,
+  isValidSpanishPhone: () => isValidSpanishPhone,
+  isValidSpanishPostalCode: () => isValidSpanishPostalCode,
+  isValidURL: () => isValidURL,
+  removeDangerousChars: () => removeDangerousChars,
+  sanitizeHtml: () => sanitizeHtml,
+  validateNIF: () => validateNIF,
+  validatePassword: () => validatePassword
+});
+module.exports = __toCommonJS(validation_exports);
+var import_crypto = require("crypto");
+var import_validator = __toESM(require("validator"));
+
+// src/environment.ts
+function isNodeEnvironment() {
+  return typeof window === "undefined" && typeof process !== "undefined" && !!process.versions?.node;
+}
+
+// src/validation.ts
+var randomInteger = (min, max) => {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+var randomString = (length, pool) => {
+  const chars = pool || "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+};
+var randomAlphaString = (length, casing) => {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  let result = randomString(length, chars);
+  if (casing === "upper") result = result.toUpperCase();
+  if (casing === "lower") result = result.toLowerCase();
+  return result;
+};
+var randomAlphaNumericString = (length, casing) => {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = randomString(length, chars);
+  if (casing === "upper") result = result.toUpperCase();
+  if (casing === "lower") result = result.toLowerCase();
+  return result;
+};
+var pickone = (array) => {
+  return array[Math.floor(Math.random() * array.length)];
+};
+var randomBool = (likelihood = 50) => {
+  return Math.random() * 100 < likelihood;
+};
+var generateRandomInteger = (min = 0, max = 100) => {
+  return randomInteger(min, max);
+};
+var generateAlphaString = (options = {}) => {
+  const { length = 10, casing = void 0 } = options;
+  return randomAlphaString(length, casing);
+};
+var generateAlphaNumericString = (options = {}) => {
+  const { length = 10, casing = void 0 } = options;
+  return randomAlphaNumericString(length, casing);
+};
+var generateComplexString = (options = {}) => {
+  const { length = 10, casing: _casing = void 0 } = options;
+  return randomString(length);
+};
+var generateUsernameFromEmail = (email, randomDigits = 1) => {
+  if (!email || !email.includes("@"))
+    return `user${Math.floor(Math.random() * Math.pow(10, randomDigits))}`;
+  const localPart = email.split("@")[0];
+  const username = localPart.toLowerCase().replace(/[^a-z0-9]/g, "").substring(0, 12);
+  const randomSuffix = Math.floor(Math.random() * Math.pow(10, randomDigits));
+  return username + randomSuffix;
+};
+var generateUsername = (separator = "", randomDigits = 1, length = 8) => {
+  const adjectives = [
+    "cool",
+    "happy",
+    "smart",
+    "fast",
+    "nice",
+    "wild",
+    "free",
+    "bold",
+    "calm",
+    "brave"
+  ];
+  const nouns = ["cat", "dog", "bird", "fish", "lion", "bear", "wolf", "tiger", "eagle", "shark"];
+  const adjective = adjectives[Math.floor(Math.random() * adjectives.length)];
+  const noun = nouns[Math.floor(Math.random() * nouns.length)];
+  const randomSuffix = Math.floor(Math.random() * Math.pow(10, randomDigits));
+  const username = adjective + separator + noun + randomSuffix;
+  return username.length > length ? username.substring(0, length) : username;
+};
+var generateSpanishNIF = () => {
+  const number = randomInteger(1e7, 99999999);
+  const letters = "TRWAGMYFPDXBNJZSQVHLCKE";
+  const letter = letters[number % 23];
+  return `${number}${letter}`;
+};
+var generateSpanishNIE = () => {
+  const prefixes = ["X", "Y", "Z"];
+  const selectedPrefix = pickone(prefixes);
+  const prefixValue = selectedPrefix === "X" ? 0 : selectedPrefix === "Y" ? 1 : 2;
+  const number = randomInteger(1e6, 9999999);
+  const letters = "TRWAGMYFPDXBNJZSQVHLCKE";
+  const calculationNumber = prefixValue * 1e7 + number;
+  const letter = letters[calculationNumber % 23];
+  return `${selectedPrefix}${number}${letter}`;
+};
+var generateSpanishCIF = () => {
+  const organizationTypes = [
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "J",
+    "N",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "U",
+    "V",
+    "W"
+  ];
+  const organizationType = pickone(organizationTypes);
+  const number = randomInteger(1e6, 9999999).toString().padStart(7, "0");
+  let sum = 0;
+  for (let i = 0; i < 7; i++) {
+    let digit = parseInt(number[i]);
+    if (i % 2 === 0) {
+      digit *= 2;
+      if (digit > 9) digit = Math.floor(digit / 10) + digit % 10;
+    }
+    sum += digit;
+  }
+  const controlDigit = (10 - sum % 10) % 10;
+  const controlLetter = "JABCDEFGHI"[controlDigit];
+  const control = ["N", "P", "Q", "R", "S", "W"].includes(organizationType) ? controlLetter : randomBool() ? controlDigit.toString() : controlLetter;
+  return `${organizationType}${number}${control}`;
+};
+var generateSpanishPostalCode = () => {
+  const validPrefixes = [
+    "01",
+    "02",
+    "03",
+    "04",
+    "05",
+    "06",
+    "07",
+    "08",
+    "09",
+    "10",
+    "11",
+    "12",
+    "13",
+    "14",
+    "15",
+    "16",
+    "17",
+    "18",
+    "19",
+    "20",
+    "21",
+    "22",
+    "23",
+    "24",
+    "25",
+    "26",
+    "27",
+    "28",
+    "29",
+    "30",
+    "31",
+    "32",
+    "33",
+    "34",
+    "35",
+    "36",
+    "37",
+    "38",
+    "39",
+    "40",
+    "41",
+    "42",
+    "43",
+    "44",
+    "45",
+    "46",
+    "47",
+    "48",
+    "49",
+    "50",
+    "51",
+    "52"
+  ];
+  const firstDigit = pickone(validPrefixes);
+  const remainingDigits = randomString(3, "0123456789");
+  return `${firstDigit}${remainingDigits}`;
+};
+var generateSpanishIBAN = () => {
+  const bankCode = randomString(4, "0123456789");
+  const branchCode = randomString(4, "0123456789");
+  const controlDigits = randomString(2, "0123456789");
+  const accountNumber = randomString(10, "0123456789");
+  const accountPart = `${bankCode}${branchCode}${controlDigits}${accountNumber}`;
+  const rearranged = `${accountPart}142800`;
+  const checkDigits = String(98n - BigInt(rearranged) % 97n).padStart(2, "0");
+  return `ES${checkDigits}${bankCode}${branchCode}${controlDigits}${accountNumber}`;
+};
+var generateEmail = (domain) => {
+  const firstNames = [
+    "Ana",
+    "Carlos",
+    "Mar\xEDa",
+    "Jos\xE9",
+    "Laura",
+    "David",
+    "Carmen",
+    "Antonio",
+    "Isabel",
+    "Manuel"
+  ];
+  const lastNames = [
+    "Garc\xEDa",
+    "Gonz\xE1lez",
+    "L\xF3pez",
+    "Mart\xEDnez",
+    "S\xE1nchez",
+    "P\xE9rez",
+    "G\xF3mez",
+    "Mart\xEDn",
+    "Jim\xE9nez",
+    "Ruiz"
+  ];
+  const domains = ["gmail.com", "hotmail.com", "yahoo.es", "outlook.com", "test.com"];
+  const firstName = pickone(firstNames);
+  const lastName = pickone(lastNames);
+  const emailDomain = domain || pickone(domains);
+  const formats = [
+    `${firstName.toLowerCase()}.${lastName.toLowerCase()}@${emailDomain}`,
+    `${firstName.toLowerCase()}${randomInteger(1, 99)}@${emailDomain}`,
+    `${firstName.toLowerCase()}.${lastName.toLowerCase()}${randomInteger(1, 9)}@${emailDomain}`,
+    `${firstName.toLowerCase()}${lastName.toLowerCase()}@${emailDomain}`
+  ];
+  const username = pickone(formats);
+  return username.toLowerCase();
+};
+var generatePassword = (options = {}) => {
+  const {
+    length = 12,
+    includeUppercase = true,
+    includeLowercase = true,
+    includeNumbers = true,
+    includeSymbols = true
+  } = options;
+  const minLength = 4;
+  const maxLength = 30;
+  const targetLength = length || randomInteger(minLength, maxLength);
+  const upperChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const lowerChars = "abcdefghijklmnopqrstuvwxyz";
+  const numberChars = "0123456789";
+  const symbolChars = "!@#$%^&*()_+-=[]{}|;:,.<>?";
+  let charset = "";
+  let requiredChars = "";
+  if (includeUppercase) {
+    charset += upperChars;
+    requiredChars += upperChars.charAt(Math.floor(Math.random() * upperChars.length));
+  }
+  if (includeLowercase) {
+    charset += lowerChars;
+    requiredChars += lowerChars.charAt(Math.floor(Math.random() * lowerChars.length));
+  }
+  if (includeNumbers) {
+    charset += numberChars;
+    requiredChars += numberChars.charAt(Math.floor(Math.random() * numberChars.length));
+  }
+  if (includeSymbols) {
+    charset += symbolChars;
+    requiredChars += symbolChars.charAt(Math.floor(Math.random() * symbolChars.length));
+  }
+  if (!charset) charset = "abcdefghijklmnopqrstuvwxyz";
+  let password = requiredChars;
+  const remainingLength = targetLength - requiredChars.length;
+  for (let i = 0; i < remainingLength; i++) {
+    password += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return password.split("").sort(() => Math.random() - 0.5).join("");
+};
+var generateHexColor = (shortFormat) => {
+  const hexChars = "0123456789ABCDEF";
+  const useShortFormat = shortFormat !== void 0 ? shortFormat : randomBool();
+  if (useShortFormat) {
+    const r = pickone(hexChars.split(""));
+    const g = pickone(hexChars.split(""));
+    const b = pickone(hexChars.split(""));
+    return `#${r}${g}${b}`;
+  } else {
+    const color = randomString(6, hexChars);
+    return `#${color}`;
+  }
+};
+var isValidNIF = (nif) => {
+  if (!nif || typeof nif !== "string") return false;
+  const cleanNif = nif.trim().toUpperCase();
+  const nifRegex = /^[0-9]{8}[TRWAGMYFPDXBNJZSQVHLCKE]$/;
+  if (!nifRegex.test(cleanNif)) return false;
+  const number = parseInt(cleanNif.substring(0, 8));
+  const letter = cleanNif.charAt(8);
+  const letters = "TRWAGMYFPDXBNJZSQVHLCKE";
+  const expectedLetter = letters[number % 23];
+  return letter === expectedLetter;
+};
+var validateNIF = isValidNIF;
+var isValidNIE = (nie) => {
+  if (!nie || typeof nie !== "string") return false;
+  const cleanNie = nie.trim().toUpperCase();
+  const nieRegex = /^[XYZ][0-9]{7}[TRWAGMYFPDXBNJZSQVHLCKE]$/;
+  if (!nieRegex.test(cleanNie)) return false;
+  const prefix = cleanNie.charAt(0);
+  const number = parseInt(cleanNie.substring(1, 8));
+  const letter = cleanNie.charAt(8);
+  const prefixValue = prefix === "X" ? 0 : prefix === "Y" ? 1 : 2;
+  const calculationNumber = prefixValue * 1e7 + number;
+  const letters = "TRWAGMYFPDXBNJZSQVHLCKE";
+  const expectedLetter = letters[calculationNumber % 23];
+  return letter === expectedLetter;
+};
+var isValidCIF = (cif) => {
+  if (!cif || typeof cif !== "string") return false;
+  const cleanCif = cif.trim().toUpperCase();
+  const cifRegex = /^[ABCDEFGHJNPQRSUVW][0-9]{7}[0-9A-J]$/;
+  if (!cifRegex.test(cleanCif)) return false;
+  const organizationType = cleanCif.charAt(0);
+  const number = cleanCif.substring(1, 8);
+  const control = cleanCif.charAt(8);
+  let sum = 0;
+  for (let i = 0; i < 7; i++) {
+    let digit = parseInt(number[i]);
+    if (i % 2 === 0) {
+      digit *= 2;
+      if (digit > 9) digit = Math.floor(digit / 10) + digit % 10;
+    }
+    sum += digit;
+  }
+  const controlDigit = (10 - sum % 10) % 10;
+  const controlLetter = "JABCDEFGHI"[controlDigit];
+  if (["N", "P", "Q", "R", "S", "W"].includes(organizationType)) {
+    return control === controlLetter;
+  } else {
+    return control === controlDigit.toString() || control === controlLetter;
+  }
+};
+var isValidSpanishPostalCode = (postalCode) => {
+  if (!postalCode || typeof postalCode !== "string") return false;
+  const cleanCode = postalCode.trim();
+  const postalCodeRegex = /^(0[1-9]|[1-4][0-9]|5[0-2])[0-9]{3}$/;
+  return postalCodeRegex.test(cleanCode);
+};
+var isValidSpanishPhone = (phone) => {
+  if (!phone || typeof phone !== "string") return false;
+  const cleanPhone = phone.replace(/[\s\-()]/g, "");
+  const phoneRegex = /^(?:\+34|0034|34)?([679][0-9]{8})$/;
+  return phoneRegex.test(cleanPhone);
+};
+var isValidEmail = (email) => {
+  if (!email || typeof email !== "string") return false;
+  return import_validator.default.isEmail(email);
+};
+var isValidURL = (url) => {
+  if (!url || typeof url !== "string") return false;
+  if (import_validator.default.isURL(url, { require_protocol: true })) {
+    return true;
+  }
+  try {
+    const urlObj = new URL(url);
+    return urlObj.hostname === "localhost" || urlObj.hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+};
+var isValidJSON = (str) => {
+  if (!str || typeof str !== "string") return false;
+  try {
+    JSON.parse(str);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isValidSpanishIBAN = (iban) => {
+  if (!iban || typeof iban !== "string") return false;
+  const cleanIban = iban.replace(/\s/g, "").toUpperCase();
+  const ibanRegex = /^ES[0-9]{22}$/;
+  if (!ibanRegex.test(cleanIban)) return false;
+  const rearranged = cleanIban.substring(4) + cleanIban.substring(0, 4);
+  const numericString = rearranged.replace(/[A-Z]/g, (letter) => {
+    return (letter.charCodeAt(0) - 55).toString();
+  });
+  let remainder = 0;
+  for (let i = 0; i < numericString.length; i++) {
+    remainder = (remainder * 10 + parseInt(numericString[i])) % 97;
+  }
+  return remainder === 1;
+};
+var validatePassword = (password, criteria = {}) => {
+  const {
+    minLength = 8,
+    requireUppercase = true,
+    requireLowercase = true,
+    requireNumbers = true,
+    requireSpecialChars = true,
+    maxLength = 128,
+    forbiddenPatterns = []
+  } = criteria;
+  const errors = [];
+  let score = 0;
+  if (password.length < minLength) {
+    errors.push(`La contrase\xF1a debe tener al menos ${minLength} caracteres`);
+  } else {
+    score += 20;
+  }
+  if (password.length > maxLength) {
+    errors.push(`La contrase\xF1a no puede tener m\xE1s de ${maxLength} caracteres`);
+  }
+  if (requireUppercase && !/[A-Z]/.test(password)) {
+    errors.push("La contrase\xF1a debe contener al menos una letra may\xFAscula");
+  } else if (/[A-Z]/.test(password)) {
+    score += 15;
+  }
+  if (requireLowercase && !/[a-z]/.test(password)) {
+    errors.push("La contrase\xF1a debe contener al menos una letra min\xFAscula");
+  } else if (/[a-z]/.test(password)) {
+    score += 15;
+  }
+  if (requireNumbers && !/\d/.test(password)) {
+    errors.push("La contrase\xF1a debe contener al menos un n\xFAmero");
+  } else if (/\d/.test(password)) {
+    score += 15;
+  }
+  if (requireSpecialChars && !/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password)) {
+    errors.push("La contrase\xF1a debe contener al menos un caracter especial");
+  } else if (/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password)) {
+    score += 15;
+  }
+  for (const pattern of forbiddenPatterns) {
+    if (password.toLowerCase().includes(pattern.toLowerCase())) {
+      errors.push(`La contrase\xF1a no puede contener: ${pattern}`);
+    }
+  }
+  if (password.length >= 12) score += 10;
+  if (password.length >= 16) score += 10;
+  if (/(.)\\1{2,}/.test(password)) score -= 10;
+  if (/123|abc|qwe/i.test(password)) score -= 15;
+  score = Math.max(0, Math.min(100, score));
+  let strength;
+  if (score < 30) strength = "weak";
+  else if (score < 60) strength = "fair";
+  else if (score < 80) strength = "good";
+  else strength = "strong";
+  return {
+    isValid: errors.length === 0,
+    errors,
+    strength,
+    score
+  };
+};
+var sanitizeHtml = (html) => {
+  if (!html) return "";
+  let sanitized = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "");
+  sanitized = sanitized.replace(/ on\w+="[^"]*"/gi, "");
+  sanitized = sanitized.replace(/ on\w+='[^']*'/gi, "");
+  sanitized = sanitized.replace(/javascript:/gi, "");
+  sanitized = sanitized.replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, "");
+  sanitized = sanitized.replace(/<object\b[^<]*(?:(?!<\/object>)<[^<]*)*<\/object>/gi, "");
+  sanitized = sanitized.replace(/<embed\b[^>]*>/gi, "");
+  return sanitized.trim();
+};
+var isValidJWTFormat = (token) => {
+  if (!token || typeof token !== "string") return false;
+  const parts = token.split(".");
+  if (parts.length !== 3) return false;
+  try {
+    for (const part of parts) {
+      if (!part || !/^[A-Za-z0-9_-]+$/.test(part)) return false;
+      atob(part.replace(/-/g, "+").replace(/_/g, "/"));
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
+var hashString = (input, salt = "") => {
+  if (!isNodeEnvironment()) {
+    let hash = 0;
+    const combined = input + salt;
+    for (let i = 0; i < combined.length; i++) {
+      const char = combined.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  }
+  return (0, import_crypto.createHash)("sha256").update(input + salt).digest("hex");
+};
+var generateSecureToken = (length = 32) => {
+  if (!isNodeEnvironment()) {
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  return (0, import_crypto.randomBytes)(length).toString("hex");
+};
+var isValidBase64 = (input) => {
+  if (!input || typeof input !== "string") return false;
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(input)) return false;
+  try {
+    const decoded = atob(input);
+    const reencoded = btoa(decoded);
+    return reencoded === input;
+  } catch {
+    return false;
+  }
+};
+var escapeShellCommand = (input) => {
+  if (!input) return "";
+  return input.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/;/g, "\\;").replace(/&/g, "\\&").replace(/\|/g, "\\|").replace(/`/g, "\\`").replace(/\$/g, "\\$").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/</g, "\\\\<").replace(/>/g, "\\\\>");
+};
+var isSecureUrl = (url) => {
+  if (!url || typeof url !== "string") return false;
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "https:" || parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1");
+  } catch {
+    return false;
+  }
+};
+var removeDangerousChars = (input, replacement = "") => {
+  if (!input) return "";
+  return input.replace(/[<>]/g, replacement).replace(/['"]/g, replacement).replace(/[&]/g, replacement).replace(/[\\x00-\\x1f\\x7f]/g, replacement);
+};
+var generateNonce = (length = 32) => {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  if (!isNodeEnvironment()) {
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    for (let i = 0; i < length; i++) {
+      result += chars[array[i] % chars.length];
+    }
+  } else {
+    const bytes = (0, import_crypto.randomBytes)(length);
+    for (let i = 0; i < length; i++) {
+      result += chars[bytes[i] % chars.length];
+    }
+  }
+  return result;
+};
+function isValidDotNotationPath(path) {
+  if (!path || typeof path !== "string") {
+    return false;
+  }
+  const trimmed = path.trim();
+  if (trimmed.length === 0) {
+    return false;
+  }
+  if (trimmed.startsWith(".") || trimmed.endsWith(".")) {
+    return false;
+  }
+  if (trimmed.includes("..")) {
+    return false;
+  }
+  const validPattern = /^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)*$/;
+  return validPattern.test(trimmed);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeShellCommand,
+  generateAlphaNumericString,
+  generateAlphaString,
+  generateComplexString,
+  generateEmail,
+  generateHexColor,
+  generateNonce,
+  generatePassword,
+  generateRandomInteger,
+  generateSecureToken,
+  generateSpanishCIF,
+  generateSpanishIBAN,
+  generateSpanishNIE,
+  generateSpanishNIF,
+  generateSpanishPostalCode,
+  generateUsername,
+  generateUsernameFromEmail,
+  hashString,
+  isSecureUrl,
+  isValidBase64,
+  isValidCIF,
+  isValidDotNotationPath,
+  isValidEmail,
+  isValidJSON,
+  isValidJWTFormat,
+  isValidNIE,
+  isValidNIF,
+  isValidSpanishIBAN,
+  isValidSpanishPhone,
+  isValidSpanishPostalCode,
+  isValidURL,
+  removeDangerousChars,
+  sanitizeHtml,
+  validateNIF,
+  validatePassword
+});
+//# sourceMappingURL=validation.js.map