@gzl10/ts-helpers 4.2.1

package/dist/cjs/index.js

@@ -0,0 +1,2035 @@
+"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/universal/index.ts
+var universal_exports = {};
+__export(universal_exports, {
+  addDays: () => addDays,
+  addMonths: () => addMonths,
+  addNowDays: () => addNowDays,
+  addNowMonths: () => addNowMonths,
+  addNowSeconds: () => addNowSeconds,
+  addNowYears: () => addNowYears,
+  addSeconds: () => addSeconds,
+  addYears: () => addYears,
+  areDatesEqualWithTolerance: () => areDatesEqualWithTolerance,
+  async: () => async_exports,
+  calculateAggregations: () => calculateAggregations,
+  calculateAnnuityPayment: () => calculateAnnuityPayment,
+  calculateCorrelation: () => calculateCorrelation,
+  calculateDifferences: () => calculateDifferences,
+  calculateEuclideanDistance: () => calculateEuclideanDistance,
+  calculateFutureValue: () => calculateFutureValue,
+  calculateHistogram: () => calculateHistogram,
+  calculateIQR: () => calculateIQR,
+  calculateIRR: () => calculateIRR,
+  calculateManhattanDistance: () => calculateManhattanDistance,
+  calculateMedian: () => calculateMedian,
+  calculateMode: () => calculateMode,
+  calculateNPV: () => calculateNPV,
+  calculatePercentile: () => calculatePercentile,
+  calculatePresentValue: () => calculatePresentValue,
+  calculateQuartiles: () => calculateQuartiles,
+  calculateStandardDeviation: () => calculateStandardDeviation,
+  calculateTrendSlope: () => calculateTrendSlope,
+  calculateVariance: () => calculateVariance,
+  capitalizeEachWord: () => capitalizeEachWord,
+  capitalizeFirst: () => capitalizeFirst,
+  cleanJsonChars: () => cleanJsonChars,
+  comparator: () => comparator,
+  contains: () => contains,
+  countOccurrences: () => countOccurrences,
+  dates: () => dates_exports,
+  dayOfWeek: () => dayOfWeek,
+  deepEqual: () => deepEqual,
+  default: () => universal_default,
+  deleteArrayElementsBy: () => deleteArrayElementsBy,
+  detectHostname: () => detectHostname,
+  detectOutliers: () => detectOutliers,
+  detectProtocol: () => detectProtocol,
+  diffBusinessDays: () => diffBusinessDays,
+  diffDays: () => diffDays,
+  diffMilliSeconds: () => diffMilliSeconds,
+  diffMonths: () => diffMonths,
+  diffYears: () => diffYears,
+  endsWith: () => endsWith,
+  ensureEndsWith: () => ensureEndsWith,
+  ensureStartsWith: () => ensureStartsWith,
+  envKeyToPath: () => envKeyToPath,
+  environment: () => environment_exports,
+  escapeHtmlChars: () => escapeHtmlChars,
+  excelToDate: () => excelToDate,
+  format: () => format,
+  formatForMysql: () => formatForMysql,
+  formatNow: () => formatNow,
+  formatToReadableString: () => formatToReadableString,
+  fromNow: () => fromNow,
+  generateAlphaNumericString: () => generateAlphaNumericString,
+  generateAlphaString: () => generateAlphaString,
+  generateComplexString: () => generateComplexString,
+  generateCrcHash: () => generateCrcHash,
+  generateEmail: () => generateEmail,
+  generateHexColor: () => generateHexColor,
+  generatePassword: () => generatePassword,
+  generateRandomInteger: () => generateRandomInteger,
+  generateSpanishCIF: () => generateSpanishCIF,
+  generateSpanishIBAN: () => generateSpanishIBAN,
+  generateSpanishNIE: () => generateSpanishNIE,
+  generateSpanishNIF: () => generateSpanishNIF,
+  generateSpanishPostalCode: () => generateSpanishPostalCode,
+  generateUsername: () => generateUsername,
+  generateUsernameFromEmail: () => generateUsernameFromEmail,
+  getCryptoCapabilities: () => getCryptoCapabilities,
+  getDeepValue: () => getDeepValue,
+  getEnvironmentInfo: () => getEnvironmentInfo,
+  getEnvironmentType: () => getEnvironmentType,
+  getFirstDayOfYear: () => getFirstDayOfYear,
+  getFirstWorkdayAfterMonths: () => getFirstWorkdayAfterMonths,
+  getFirstWorkdayOfMonth: () => getFirstWorkdayOfMonth,
+  getLastDayOfYear: () => getLastDayOfYear,
+  getLastWorkdayOfMonth: () => getLastWorkdayOfMonth,
+  getShallowProperties: () => getShallowProperties,
+  handleOperation: () => handleOperation,
+  hasSameType: () => hasSameType,
+  isBrowser: () => isBrowser,
+  isBrowserEnv: () => isBrowserEnv,
+  isBrowserEnvironment: () => isBrowserEnvironment,
+  isDateTime: () => isDateTime,
+  isDevelopment: () => isDevelopment,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  isEqualsDateTimeByDay: () => isEqualsDateTimeByDay,
+  isExpired: () => isExpired,
+  isLocalhost: () => isLocalhost,
+  isNew: () => isNew,
+  isNode: () => isNode,
+  isNodeCryptoAvailable: () => isNodeCryptoAvailable,
+  isNodeEnv: () => isNodeEnv,
+  isNodeEnvironment: () => isNodeEnvironment,
+  isNonProduction: () => isNonProduction,
+  isNumericValue: () => isNumericValue,
+  isPrivateIP: () => isPrivateIP,
+  isProduction: () => isProduction,
+  isTest: () => isTest,
+  isValidCIF: () => isValidCIF,
+  isValidEmail: () => isValidEmail,
+  isValidJSON: () => isValidJSON,
+  isValidNIE: () => isValidNIE,
+  isValidNIF: () => isValidNIF,
+  isValidSpanishIBAN: () => isValidSpanishIBAN,
+  isValidSpanishPhone: () => isValidSpanishPhone,
+  isValidSpanishPostalCode: () => isValidSpanishPostalCode,
+  isValidURL: () => isValidURL,
+  isWebCryptoAvailable: () => isWebCryptoAvailable,
+  isWeekday: () => isWeekday,
+  isWorkerEnvironment: () => isWorkerEnvironment,
+  longString: () => longString,
+  matchPathPattern: () => matchPathPattern,
+  math: () => math_exports,
+  normalizeToRange: () => normalizeToRange,
+  now: () => now,
+  number: () => number_exports,
+  objects: () => objects_exports,
+  padEnd: () => padEnd,
+  padStart: () => padStart,
+  parseEnvValue: () => parseEnvValue,
+  pathToEnvKey: () => pathToEnvKey,
+  removeAccents: () => removeAccents,
+  repeatString: () => repeatString,
+  replaceAllOccurrences: () => replaceAllOccurrences,
+  reverseString: () => reverseString,
+  roundToDecimals: () => roundToDecimals,
+  runBatch: () => runBatch,
+  sanitizeString: () => sanitizeString,
+  scaleToRange: () => scaleToRange,
+  setDeepValue: () => setDeepValue,
+  simpleKMeans: () => simpleKMeans,
+  sleep: () => sleep,
+  startsWith: () => startsWith,
+  strings: () => strings_exports,
+  stripFromEnd: () => stripFromEnd,
+  stripFromStart: () => stripFromStart,
+  toCamelCase: () => toCamelCase,
+  toDate: () => toDate,
+  toDateFromString: () => toDateFromString,
+  toISO: () => toISO,
+  toKebabCase: () => toKebabCase,
+  toLowerCase: () => toLowerCase,
+  toPascalCase: () => toPascalCase,
+  toSnakeCase: () => toSnakeCase,
+  toUpperCase: () => toUpperCase,
+  toUrlSlug: () => toUrlSlug,
+  trim: () => trim,
+  trimEnd: () => trimEnd,
+  trimStart: () => trimStart,
+  truncateString: () => truncateString,
+  unescapeHtmlChars: () => unescapeHtmlChars,
+  unescapeUnicode: () => unescapeUnicode,
+  updateArrayElementById: () => updateArrayElementById,
+  updateArrayElementsBy: () => updateArrayElementsBy,
+  validateNIF: () => validateNIF,
+  validation: () => validation_core_exports,
+  wait: () => wait,
+  weekOfYear: () => weekOfYear
+});
+module.exports = __toCommonJS(universal_exports);
+
+// src/universal/validation-core.ts
+var validation_core_exports = {};
+__export(validation_core_exports, {
+  generateAlphaNumericString: () => generateAlphaNumericString,
+  generateAlphaString: () => generateAlphaString,
+  generateComplexString: () => generateComplexString,
+  generateEmail: () => generateEmail,
+  generateHexColor: () => generateHexColor,
+  generatePassword: () => generatePassword,
+  generateRandomInteger: () => generateRandomInteger,
+  generateSpanishCIF: () => generateSpanishCIF,
+  generateSpanishIBAN: () => generateSpanishIBAN,
+  generateSpanishNIE: () => generateSpanishNIE,
+  generateSpanishNIF: () => generateSpanishNIF,
+  generateSpanishPostalCode: () => generateSpanishPostalCode,
+  generateUsername: () => generateUsername,
+  generateUsernameFromEmail: () => generateUsernameFromEmail,
+  isValidCIF: () => isValidCIF,
+  isValidEmail: () => isValidEmail,
+  isValidJSON: () => isValidJSON,
+  isValidNIE: () => isValidNIE,
+  isValidNIF: () => isValidNIF,
+  isValidSpanishIBAN: () => isValidSpanishIBAN,
+  isValidSpanishPhone: () => isValidSpanishPhone,
+  isValidSpanishPostalCode: () => isValidSpanishPostalCode,
+  isValidURL: () => isValidURL,
+  validateNIF: () => validateNIF
+});
+var import_validator = __toESM(require("validator"));
+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 sum2 = 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;
+    }
+    sum2 += digit;
+  }
+  const controlDigit = (10 - sum2 % 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 g2 = pickone(hexChars.split(""));
+    const b = pickone(hexChars.split(""));
+    return `#${r}${g2}${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 sum2 = 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;
+    }
+    sum2 += digit;
+  }
+  const controlDigit = (10 - sum2 % 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;
+};
+
+// src/universal/environment-detection.ts
+var environment_detection_exports = {};
+__export(environment_detection_exports, {
+  getCryptoCapabilities: () => getCryptoCapabilities,
+  getEnvironmentType: () => getEnvironmentType,
+  isBrowserEnv: () => isBrowserEnv,
+  isNodeCryptoAvailable: () => isNodeCryptoAvailable,
+  isNodeEnv: () => isNodeEnv,
+  isWebCryptoAvailable: () => isWebCryptoAvailable,
+  isWorkerEnvironment: () => isWorkerEnvironment
+});
+
+// src/environment.ts
+var environment_exports = {};
+__export(environment_exports, {
+  detectHostname: () => detectHostname,
+  detectProtocol: () => detectProtocol,
+  getEnvironmentInfo: () => getEnvironmentInfo,
+  isBrowser: () => isBrowser,
+  isBrowserEnvironment: () => isBrowserEnvironment,
+  isDevelopment: () => isDevelopment,
+  isLocalhost: () => isLocalhost,
+  isNode: () => isNode,
+  isNodeEnvironment: () => isNodeEnvironment,
+  isNonProduction: () => isNonProduction,
+  isPrivateIP: () => isPrivateIP,
+  isProduction: () => isProduction,
+  isTest: () => isTest,
+  parseEnvValue: () => parseEnvValue
+});
+function isNodeEnvironment() {
+  return typeof window === "undefined" && typeof process !== "undefined" && !!process.versions?.node;
+}
+function isBrowserEnvironment() {
+  const win = typeof window !== "undefined" ? window : global.window;
+  const doc = typeof document !== "undefined" ? document : global.document;
+  return typeof win !== "undefined" && win !== null && typeof doc !== "undefined" && doc !== null;
+}
+function isDevelopment(req) {
+  if (isNodeEnvironment()) {
+    if (process.env.NODE_ENV === "production") {
+      return false;
+    }
+    if (process.env.NODE_ENV === "development") {
+      return true;
+    }
+    if (req) {
+      const protocol = detectProtocol(req);
+      const hostname = detectHostname(req);
+      return protocol === "http" || isLocalhost(hostname) || isPrivateIP(hostname);
+    }
+    return !process.env.NODE_ENV || process.env.NODE_ENV === "development";
+  }
+  if (isBrowserEnvironment()) {
+    if (typeof globalThis.__DEV__ !== "undefined" && globalThis.__DEV__ === true) {
+      return true;
+    }
+    if (typeof window !== "undefined" && window.__VUE_DEVTOOLS_GLOBAL_HOOK__ && typeof location !== "undefined" && isLocalhost(location.hostname)) {
+      return true;
+    }
+    if (typeof location === "undefined") {
+      return false;
+    }
+    const hostname = location.hostname || "";
+    const port = parseInt(location.port || "80");
+    const isDevelopmentPort = port >= 3e3 && port <= 9999;
+    const isHttpDevelopment = location.protocol === "http:" && (isLocalhost(hostname) || isPrivateIP(hostname));
+    return isLocalhost(hostname) || isPrivateIP(hostname) || isDevelopmentPort || isHttpDevelopment;
+  }
+  return false;
+}
+function isProduction() {
+  if (isNodeEnvironment()) {
+    return process.env.NODE_ENV === "production";
+  }
+  return !isDevelopment();
+}
+function isTest() {
+  if (isNodeEnvironment()) {
+    return process.env.NODE_ENV === "test";
+  }
+  return false;
+}
+function isNonProduction() {
+  if (isNodeEnvironment()) {
+    return process.env.NODE_ENV !== "production";
+  }
+  return !isProduction();
+}
+function detectProtocol(req) {
+  if (isBrowserEnvironment()) {
+    if (typeof location !== "undefined") {
+      return location.protocol === "https:" ? "https" : "http";
+    }
+    return "https";
+  }
+  if (req) {
+    const forwardedProto = req.get?.("X-Forwarded-Proto") || req.headers?.["x-forwarded-proto"];
+    const forwardedProtocol = req.get?.("X-Forwarded-Protocol") || req.headers?.["x-forwarded-protocol"];
+    const urlScheme = req.get?.("X-Url-Scheme") || req.headers?.["x-url-scheme"];
+    const frontEndHttps = req.get?.("Front-End-Https") || req.headers?.["front-end-https"];
+    const cloudflareVisitor = req.get?.("CF-Visitor") || req.headers?.["cf-visitor"];
+    if (forwardedProto) {
+      return forwardedProto.split(",")[0].trim().toLowerCase();
+    }
+    if (forwardedProtocol) {
+      return forwardedProtocol.toLowerCase();
+    }
+    if (urlScheme) {
+      return urlScheme.toLowerCase();
+    }
+    if (frontEndHttps === "on") {
+      return "https";
+    }
+    if (cloudflareVisitor) {
+      try {
+        const visitor = JSON.parse(cloudflareVisitor);
+        if (visitor.scheme) {
+          return visitor.scheme.toLowerCase();
+        }
+      } catch (_e) {
+      }
+    }
+    if (req.protocol) return req.protocol;
+    if (req.secure) return "https";
+  }
+  return "http";
+}
+function detectHostname(req) {
+  if (isBrowserEnvironment()) {
+    if (typeof location !== "undefined") {
+      return location.hostname;
+    }
+    return "localhost";
+  }
+  if (req) {
+    const forwardedHost = req.get?.("X-Forwarded-Host") || req.headers?.["x-forwarded-host"];
+    const originalHost = req.get?.("X-Original-Host") || req.headers?.["x-original-host"];
+    const host = req.get?.("Host") || req.headers?.["host"];
+    if (forwardedHost) {
+      return forwardedHost.split(",")[0].trim().split(":")[0];
+    }
+    if (originalHost) {
+      return originalHost.split(":")[0];
+    }
+    if (host) {
+      return host.split(":")[0];
+    }
+    if (req.hostname) return req.hostname;
+  }
+  return "localhost";
+}
+function isLocalhost(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".local");
+}
+function isPrivateIP(hostname) {
+  const ipv4Patterns = [
+    /^10\./,
+    // 10.0.0.0/8
+    /^172\.(1[6-9]|2[0-9]|3[0-1])\./,
+    // 172.16.0.0/12
+    /^192\.168\./,
+    // 192.168.0.0/16
+    /^127\./
+    // 127.0.0.0/8 (loopback)
+  ];
+  const ipv6Patterns = [
+    /^::1$/,
+    // IPv6 loopback
+    /^fc[0-9a-f]{2}:/i,
+    // Unique local addresses
+    /^fd[0-9a-f]{2}:/i,
+    // Unique local addresses
+    /^fe80:/i
+    // Link-local addresses
+  ];
+  return ipv4Patterns.some((pattern) => pattern.test(hostname)) || ipv6Patterns.some((pattern) => pattern.test(hostname)) || isLocalhost(hostname);
+}
+function getEnvironmentInfo(req) {
+  const platform = isNodeEnvironment() ? "node" : isBrowserEnvironment() ? "browser" : "unknown";
+  let environment = "production";
+  if (isNodeEnvironment()) {
+    const nodeEnv = process.env.NODE_ENV;
+    if (nodeEnv === "development" || nodeEnv === "test") {
+      environment = nodeEnv;
+    }
+  } else if (isDevelopment()) {
+    environment = "development";
+  }
+  const protocol = detectProtocol(req);
+  const hostname = detectHostname(req);
+  const info = {
+    platform,
+    environment,
+    protocol,
+    hostname
+  };
+  if (isBrowserEnvironment() && typeof navigator !== "undefined") {
+    info.userAgent = navigator.userAgent;
+  }
+  const criteria = {
+    isLocalhost: isLocalhost(hostname),
+    isPrivateIP: isPrivateIP(hostname),
+    isDevelopmentPort: false,
+    hasDevtools: false
+  };
+  if (isBrowserEnvironment() && typeof location !== "undefined") {
+    const port = parseInt(location.port || "80");
+    criteria.isDevelopmentPort = port >= 3e3 && port <= 9999;
+    criteria.hasDevtools = !!(typeof window !== "undefined" && window.__VUE_DEVTOOLS_GLOBAL_HOOK__);
+  }
+  if (isNodeEnvironment()) {
+    criteria.nodeEnv = process.env.NODE_ENV || "undefined";
+  }
+  info.criteria = criteria;
+  return info;
+}
+var isNode = isNodeEnvironment;
+var isBrowser = isBrowserEnvironment;
+function parseEnvValue(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "null") return null;
+  if (trimmed === "undefined") return void 0;
+  const lowerValue = trimmed.toLowerCase();
+  if (lowerValue === "true" || lowerValue === "yes") return true;
+  if (lowerValue === "false" || lowerValue === "no") return false;
+  if (trimmed === "1") return true;
+  if (trimmed === "0") return false;
+  if (/^-?\d+\.?\d*$/.test(trimmed)) {
+    if (trimmed.length > 1 && trimmed[0] === "0" && trimmed[1] !== ".") {
+      return trimmed;
+    }
+    const num = Number(trimmed);
+    if (!isNaN(num)) return num;
+  }
+  if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+    }
+  }
+  if (trimmed.includes(",")) {
+    const parts = trimmed.split(",").map((s) => s.trim());
+    if (parts.every((p) => p.length > 0)) {
+      return parts;
+    }
+  }
+  return trimmed;
+}
+
+// src/universal/environment-detection.ts
+var isBrowserEnv = isBrowserEnvironment;
+var isNodeEnv = isNodeEnvironment;
+var isWorkerEnvironment = () => {
+  try {
+    return typeof importScripts === "function" && typeof self !== "undefined" && // Check for Worker global scope without importing types
+    "importScripts" in self;
+  } catch {
+    return false;
+  }
+};
+var isWebCryptoAvailable = () => {
+  try {
+    return typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function" && typeof crypto.subtle === "object";
+  } catch {
+    return false;
+  }
+};
+var isNodeCryptoAvailable = () => {
+  try {
+    if (!isNodeEnv()) return false;
+    const crypto2 = require("crypto");
+    return typeof crypto2.createHash === "function" && typeof crypto2.randomBytes === "function";
+  } catch {
+    return false;
+  }
+};
+var getEnvironmentType = () => {
+  if (isNodeEnv()) return "node";
+  if (isWorkerEnvironment()) return "worker";
+  if (isBrowserEnv()) return "browser";
+  return "unknown";
+};
+var getCryptoCapabilities = () => {
+  return {
+    webCrypto: isWebCryptoAvailable(),
+    nodeCrypto: isNodeCryptoAvailable(),
+    fallbackOnly: !isWebCryptoAvailable() && !isNodeCryptoAvailable(),
+    environment: getEnvironmentType()
+  };
+};
+
+// src/strings.ts
+var strings_exports = {};
+__export(strings_exports, {
+  capitalizeEachWord: () => capitalizeEachWord,
+  capitalizeFirst: () => capitalizeFirst,
+  cleanJsonChars: () => cleanJsonChars,
+  contains: () => contains,
+  countOccurrences: () => countOccurrences,
+  endsWith: () => endsWith,
+  ensureEndsWith: () => ensureEndsWith,
+  ensureStartsWith: () => ensureStartsWith,
+  envKeyToPath: () => envKeyToPath,
+  escapeHtmlChars: () => escapeHtmlChars,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  matchPathPattern: () => matchPathPattern,
+  padEnd: () => padEnd,
+  padStart: () => padStart,
+  pathToEnvKey: () => pathToEnvKey,
+  removeAccents: () => removeAccents,
+  repeatString: () => repeatString,
+  replaceAllOccurrences: () => replaceAllOccurrences,
+  reverseString: () => reverseString,
+  sanitizeString: () => sanitizeString,
+  startsWith: () => startsWith,
+  stripFromEnd: () => stripFromEnd,
+  stripFromStart: () => stripFromStart,
+  toCamelCase: () => toCamelCase,
+  toKebabCase: () => toKebabCase,
+  toLowerCase: () => toLowerCase,
+  toPascalCase: () => toPascalCase,
+  toSnakeCase: () => toSnakeCase,
+  toUpperCase: () => toUpperCase,
+  toUrlSlug: () => toUrlSlug,
+  trim: () => trim,
+  trimEnd: () => trimEnd,
+  trimStart: () => trimStart,
+  truncateString: () => truncateString,
+  unescapeHtmlChars: () => unescapeHtmlChars,
+  unescapeUnicode: () => unescapeUnicode
+});
+var sanitizeString = (instr) => {
+  if (!instr) return "";
+  return addDash(instr.replace(/[^a-zA-Z0-9 ]/g, "")).toLowerCase();
+};
+function addDash(str) {
+  const str2 = str.replace(/[`~!@#$%^&*()_|+\-=?;:'",.<>{}[\]\\/]/gi, "");
+  return str2.replace(/ /g, "-");
+}
+var cleanJsonChars = (texto) => {
+  if (!texto) return "";
+  return texto.replace(/({|}|&amp;|amp;|gt;)/g, "");
+};
+var truncateString = (str, maxlength = 80, suffix = "...") => {
+  if (!str) return "";
+  return str.length > maxlength ? str.substring(0, maxlength) + suffix : str;
+};
+var unescapeUnicode = (input) => {
+  return JSON.stringify(JSON.parse(`"${input}"`)).replace(/^"(.*)"$/, "$1");
+};
+var ensureEndsWith = (str, trailing) => {
+  return str.endsWith(trailing) ? str : `${str}${trailing}`;
+};
+var stripFromEnd = (str, trailing) => {
+  return str.endsWith(trailing) ? str.slice(0, -1 * trailing.length) : str;
+};
+var ensureStartsWith = (str, leading) => {
+  return str.startsWith(leading) ? str : `${leading}${str}`;
+};
+var stripFromStart = (str, leading) => {
+  return str.startsWith(leading) ? str.slice(leading.length) : str;
+};
+var toLowerCase = (str) => {
+  return str.toLowerCase();
+};
+var toUpperCase = (str) => {
+  return str.toUpperCase();
+};
+var capitalizeFirst = (str) => {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+var capitalizeEachWord = (str) => {
+  if (!str) return "";
+  return str.split(" ").map((word) => capitalizeFirst(word)).join(" ");
+};
+var toCamelCase = (str) => {
+  if (!str) return "";
+  const words = str.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[-_\s]+/).filter((word) => word.length > 0).map((word) => word.toLowerCase());
+  if (words.length === 0) return "";
+  return words[0] + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+};
+var toSnakeCase = (str) => {
+  if (!str) return "";
+  return str.replace(/\W+/g, " ").split(/ |\B(?=[A-Z])/).map((word) => word.toLowerCase()).join("_");
+};
+var toKebabCase = (str) => {
+  if (!str) return "";
+  return str.replace(/[_\s]+/g, "-").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+};
+var toPascalCase = (str) => {
+  if (!str) return "";
+  return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toUpperCase());
+};
+var contains = (str, searchStr, caseSensitive = false) => {
+  if (caseSensitive) {
+    return str.includes(searchStr);
+  }
+  return str.toLowerCase().includes(searchStr.toLowerCase());
+};
+var startsWith = (str, searchStr, caseSensitive = false) => {
+  if (caseSensitive) {
+    return str.startsWith(searchStr);
+  }
+  return str.toLowerCase().startsWith(searchStr.toLowerCase());
+};
+var endsWith = (str, searchStr, caseSensitive = false) => {
+  if (caseSensitive) {
+    return str.endsWith(searchStr);
+  }
+  return str.toLowerCase().endsWith(searchStr.toLowerCase());
+};
+var padStart = (str, length, padChar = " ") => {
+  return str.padStart(length, padChar);
+};
+var padEnd = (str, length, padChar = " ") => {
+  if (str.length >= length) return str;
+  return str + padChar.repeat(length - str.length);
+};
+var trim = (str) => {
+  return str.trim();
+};
+var trimStart = (str) => {
+  return str.trimStart();
+};
+var trimEnd = (str) => {
+  return str.trimEnd();
+};
+var reverseString = (str) => {
+  return str.split("").reverse().join("");
+};
+var repeatString = (str, times) => {
+  return str.repeat(times);
+};
+var replaceAllOccurrences = (str, searchStr, replaceStr) => {
+  return str.split(searchStr).join(replaceStr);
+};
+var countOccurrences = (str, searchStr) => {
+  if (!searchStr) return 0;
+  let count = 0;
+  let position = 0;
+  while ((position = str.indexOf(searchStr, position)) !== -1) {
+    count++;
+    position += 1;
+  }
+  return count;
+};
+var isEmpty = (str) => {
+  return !str || str.trim().length === 0;
+};
+var isEmail = (str) => {
+  const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+  return re.test(str.toLowerCase());
+};
+var toUrlSlug = (str) => {
+  return str.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+};
+var removeAccents = (str) => {
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+};
+var escapeHtmlChars = (str) => {
+  const htmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (match) => htmlEscapes[match]);
+};
+var unescapeHtmlChars = (str) => {
+  const htmlUnescapes = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return str.replace(/&amp;|&lt;|&gt;|&quot;|&#39;/g, (match) => htmlUnescapes[match]);
+};
+function matchPathPattern(path, pattern) {
+  if (!path || typeof path !== "string" || !pattern || typeof pattern !== "string") {
+    return false;
+  }
+  if (path === pattern) {
+    return true;
+  }
+  if (!pattern.includes("*")) {
+    return path === pattern;
+  }
+  const regexPattern = pattern.split(".").map((segment) => {
+    if (segment === "*") {
+      return "[^.]+";
+    }
+    return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }).join("\\.");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+function envKeyToPath(envKey, prefix = "NX") {
+  if (!envKey || typeof envKey !== "string") {
+    return "";
+  }
+  let key = envKey.trim();
+  if (prefix && key.startsWith(`${prefix}_`)) {
+    key = key.substring(prefix.length + 1);
+  }
+  return key.toLowerCase().replace(/_/g, ".");
+}
+function pathToEnvKey(path, prefix = "NX") {
+  if (!path || typeof path !== "string") {
+    return "";
+  }
+  const key = path.trim().toUpperCase().replace(/\./g, "_");
+  if (key.length === 0) {
+    return "";
+  }
+  if (prefix && prefix.length > 0) {
+    return `${prefix.toUpperCase()}_${key}`;
+  }
+  return key;
+}
+
+// src/objects.ts
+var objects_exports = {};
+__export(objects_exports, {
+  calculateDifferences: () => calculateDifferences,
+  comparator: () => comparator,
+  deepEqual: () => deepEqual,
+  deleteArrayElementsBy: () => deleteArrayElementsBy,
+  formatToReadableString: () => formatToReadableString,
+  generateCrcHash: () => generateCrcHash,
+  getDeepValue: () => getDeepValue,
+  getShallowProperties: () => getShallowProperties,
+  hasSameType: () => hasSameType,
+  setDeepValue: () => setDeepValue,
+  updateArrayElementById: () => updateArrayElementById,
+  updateArrayElementsBy: () => updateArrayElementsBy
+});
+var import_crc32 = __toESM(require("crc/crc32"));
+var lodash = __toESM(require("lodash"));
+var import_fast_deep_equal = __toESM(require("fast-deep-equal"));
+
+// src/dates.ts
+var dates_exports = {};
+__export(dates_exports, {
+  addDays: () => addDays,
+  addMonths: () => addMonths,
+  addNowDays: () => addNowDays,
+  addNowMonths: () => addNowMonths,
+  addNowSeconds: () => addNowSeconds,
+  addNowYears: () => addNowYears,
+  addSeconds: () => addSeconds,
+  addYears: () => addYears,
+  areDatesEqualWithTolerance: () => areDatesEqualWithTolerance,
+  dayOfWeek: () => dayOfWeek,
+  diffBusinessDays: () => diffBusinessDays,
+  diffDays: () => diffDays,
+  diffMilliSeconds: () => diffMilliSeconds,
+  diffMonths: () => diffMonths,
+  diffYears: () => diffYears,
+  excelToDate: () => excelToDate,
+  format: () => format,
+  formatForMysql: () => formatForMysql,
+  formatNow: () => formatNow,
+  fromNow: () => fromNow,
+  getFirstDayOfYear: () => getFirstDayOfYear,
+  getFirstWorkdayAfterMonths: () => getFirstWorkdayAfterMonths,
+  getFirstWorkdayOfMonth: () => getFirstWorkdayOfMonth,
+  getLastDayOfYear: () => getLastDayOfYear,
+  getLastWorkdayOfMonth: () => getLastWorkdayOfMonth,
+  isDateTime: () => isDateTime,
+  isEqualsDateTimeByDay: () => isEqualsDateTimeByDay,
+  isExpired: () => isExpired,
+  isNew: () => isNew,
+  isWeekday: () => isWeekday,
+  longString: () => longString,
+  now: () => now,
+  toDate: () => toDate,
+  toDateFromString: () => toDateFromString,
+  toISO: () => toISO,
+  weekOfYear: () => weekOfYear
+});
+var import_dayjs = __toESM(require("dayjs"));
+var import_utc = __toESM(require("dayjs/plugin/utc.js"));
+var import_relativeTime = __toESM(require("dayjs/plugin/relativeTime.js"));
+var import_weekOfYear = __toESM(require("dayjs/plugin/weekOfYear.js"));
+var import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat.js"));
+var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter.js"));
+var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore.js"));
+var import_weekday = __toESM(require("dayjs/plugin/weekday.js"));
+var import_localeData = __toESM(require("dayjs/plugin/localeData.js"));
+var import_localizedFormat = __toESM(require("dayjs/plugin/localizedFormat.js"));
+var import_es = require("dayjs/locale/es.js");
+var dateValidator = __toESM(require("iso-datestring-validator"));
+var { isValidDate, isValidISODateString } = dateValidator;
+import_dayjs.default.extend(import_utc.default);
+import_dayjs.default.extend(import_relativeTime.default);
+import_dayjs.default.extend(import_weekOfYear.default);
+import_dayjs.default.extend(import_customParseFormat.default);
+import_dayjs.default.extend(import_isSameOrAfter.default);
+import_dayjs.default.extend(import_isSameOrBefore.default);
+import_dayjs.default.extend(import_weekday.default);
+import_dayjs.default.extend(import_localeData.default);
+import_dayjs.default.extend(import_localizedFormat.default);
+import_dayjs.default.locale("es");
+var formatNow = (formatStr = "DD/MM/YYYY") => (0, import_dayjs.default)().format(formatStr);
+var format = (value, formatStr = "DD/MM/YYYY") => {
+  if (!value) return "";
+  if (formatStr.toLowerCase() === "gg") return weekOfYear(value);
+  else if (formatStr.toLowerCase() === "gggg") return (0, import_dayjs.default)(value).format("YY") + weekOfYear(value);
+  return (0, import_dayjs.default)(value).format(formatStr);
+};
+var longString = (value = null) => {
+  if (!value) return "";
+  return (0, import_dayjs.default)(value).format("LL");
+};
+var toDate = (value, isUtc) => {
+  if (isUtc === void 0) return (0, import_dayjs.default)(value).toDate();
+  return isUtc ? import_dayjs.default.utc(value).toDate() : (0, import_dayjs.default)(value).toDate();
+};
+var toDateFromString = (dateString, format2) => {
+  const formatRegex = {
+    "DD/MM/YYYY": /^(\d{2})\/(\d{2})\/(\d{4})$/,
+    "YYYY-MM-DD": /^(\d{4})-(\d{2})-(\d{2})$/,
+    "MM/DD/YYYY": /^(\d{2})\/(\d{2})\/(\d{4})$/,
+    "YYYY/MM/DD": /^(\d{4})\/(\d{2})\/(\d{2})$/,
+    "DD-MM-YYYY": /^(\d{2})-(\d{2})-(\d{4})$/,
+    "MM-DD-YYYY": /^(\d{2})-(\d{2})-(\d{4})$/,
+    YYYYMMDD: /^(\d{4})(\d{2})(\d{2})$/,
+    DDMMYYYY: /^(\d{2})(\d{2})(\d{4})$/,
+    MMDDYYYY: /^(\d{2})(\d{2})(\d{4})$/,
+    "YYYY.MM.DD": /^(\d{4})\.(\d{2})\.(\d{2})$/,
+    "DD.MM.YYYY": /^(\d{2})\.(\d{2})\.(\d{4})$/,
+    "MM.DD.YYYY": /^(\d{2})\.(\d{2})\.(\d{4})$/
+  };
+  const regex = formatRegex[format2];
+  if (!regex) return null;
+  const match = dateString.match(regex);
+  if (match) {
+    let year, month, day;
+    if (format2.startsWith("YYYY")) {
+      year = parseInt(match[1], 10);
+      month = parseInt(match[2], 10) - 1;
+      day = parseInt(match[3], 10);
+    } else if (format2.startsWith("DD")) {
+      day = parseInt(match[1], 10);
+      month = parseInt(match[2], 10) - 1;
+      year = parseInt(match[3], 10);
+    } else if (format2.startsWith("MM")) {
+      month = parseInt(match[1], 10) - 1;
+      day = parseInt(match[2], 10);
+      year = parseInt(match[3], 10);
+    } else {
+      return null;
+    }
+    return new Date(year, month, day);
+  }
+  return null;
+};
+var now = () => (0, import_dayjs.default)().toDate();
+var isNew = (value, daysnew = 1) => (0, import_dayjs.default)().isSameOrBefore((0, import_dayjs.default)(value).add(daysnew, "days"));
+var toISO = (value = null, isUtc = false) => {
+  if (!value) return (0, import_dayjs.default)().toISOString();
+  return isUtc ? import_dayjs.default.utc(value).toISOString() : (0, import_dayjs.default)(value).toISOString();
+};
+var fromNow = (value) => (0, import_dayjs.default)(value).fromNow();
+var dayOfWeek = (value = null) => {
+  if (!value) return (0, import_dayjs.default)().format("d");
+  return (0, import_dayjs.default)(value).format("d");
+};
+var weekOfYear = (value = null) => {
+  if (!value) return (0, import_dayjs.default)().locale("es").week().toString().padStart(2, "0");
+  return (0, import_dayjs.default)(value).locale("es").week().toString().padStart(2, "0");
+};
+var diffDays = (start, end = null, precise = false) => {
+  const v2 = !end ? (0, import_dayjs.default)() : (0, import_dayjs.default)(end);
+  return (0, import_dayjs.default)(start).diff(v2, "days", precise);
+};
+var diffBusinessDays = (start, end = null, precise = false) => {
+  let startDate = (0, import_dayjs.default)(start).startOf("day");
+  let endDate = end ? (0, import_dayjs.default)(end).startOf("day") : (0, import_dayjs.default)().startOf("day");
+  if (startDate.isAfter(endDate)) {
+    ;
+    [startDate, endDate] = [endDate, startDate];
+  }
+  let businessDays = 0;
+  let currentDate = startDate;
+  while (currentDate.isBefore(endDate)) {
+    if (isWeekday(currentDate)) {
+      businessDays++;
+    }
+    currentDate = currentDate.add(1, "day");
+  }
+  if (precise) {
+    const fractionalDay = endDate.diff(currentDate, "hours") / 24;
+    businessDays += fractionalDay;
+  }
+  return businessDays;
+};
+var diffMonths = (value, valueRefOrNow = null, precise = false) => {
+  const v2 = !valueRefOrNow ? (0, import_dayjs.default)() : (0, import_dayjs.default)(valueRefOrNow);
+  return (0, import_dayjs.default)(value).diff(v2, "months", precise);
+};
+var diffYears = (value, valueRefOrNow = null, precise = false) => {
+  const v2 = !valueRefOrNow ? (0, import_dayjs.default)() : (0, import_dayjs.default)(valueRefOrNow);
+  return (0, import_dayjs.default)(value).diff(v2, "years", precise);
+};
+var diffMilliSeconds = (value, valueRefOrNow = null) => {
+  const v2 = !valueRefOrNow ? (0, import_dayjs.default)() : (0, import_dayjs.default)(valueRefOrNow);
+  return (0, import_dayjs.default)(value).diff(v2, "milliseconds", true);
+};
+var addDays = (value, nDays = 1) => (0, import_dayjs.default)(value).add(nDays, "days").toDate();
+var addSeconds = (value, nSeconds = 1) => (0, import_dayjs.default)(value).add(nSeconds, "seconds").toDate();
+var areDatesEqualWithTolerance = (date1, date2) => {
+  const tolerance = 2 * 1e3;
+  return Math.abs((0, import_dayjs.default)(date1).diff((0, import_dayjs.default)(date2))) <= tolerance;
+};
+var addNowDays = (nDays = 1) => (0, import_dayjs.default)().add(nDays, "days").toDate();
+var addNowSeconds = (nSeconds = 60) => (0, import_dayjs.default)().add(nSeconds, "seconds").toDate();
+var addMonths = (value, nMonths = 1) => (0, import_dayjs.default)(value).add(nMonths, "months").toDate();
+var addNowMonths = (nMonths = 1) => (0, import_dayjs.default)().add(nMonths, "months").toDate();
+var addYears = (value, nYears = 1) => (0, import_dayjs.default)(value).add(nYears, "years").toDate();
+var addNowYears = (nYears = 1) => (0, import_dayjs.default)().add(nYears, "years").toDate();
+var excelToDate = (value) => {
+  try {
+    const d = Number(value);
+    if (d >= 18e3 && d <= 3e5) return new Date(Math.round((d - 25569) * 86400 * 1e3));
+    return null;
+  } catch (_err) {
+    return null;
+  }
+};
+var isDateTime = (value) => {
+  try {
+    if (!value) return false;
+    if (typeof value === "number") return false;
+    else if (typeof value === "boolean") return false;
+    else if (typeof value === "string" && !isValidISODateString(value) && !isValidDate(value) && !isValidDate(value, ""))
+      return false;
+    else if (typeof value === "object" && !(value instanceof Date) && !import_dayjs.default.isDayjs(value))
+      return false;
+    return (0, import_dayjs.default)(value).isValid();
+  } catch (_err) {
+    return false;
+  }
+};
+var isEqualsDateTimeByDay = (value1, value2) => {
+  if (!isDateTime(value1)) return false;
+  if (!isDateTime(value2)) return false;
+  return (0, import_dayjs.default)(value1).isSame((0, import_dayjs.default)(value2), "day");
+};
+var isExpired = (value, valueRefOrNow = null) => {
+  const v2 = !valueRefOrNow ? (0, import_dayjs.default)() : (0, import_dayjs.default)(valueRefOrNow);
+  if (isDateTime(value)) {
+    return v2.isAfter(value);
+  }
+  return true;
+};
+var formatForMysql = (fecha) => {
+  if (!fecha) return null;
+  fecha.setMinutes(fecha.getMinutes() - fecha.getTimezoneOffset());
+  return fecha.toISOString().slice(0, 19).replace("T", " ");
+};
+var getFirstWorkdayOfMonth = (month) => {
+  const monthToUse = month === void 0 ? (0, import_dayjs.default)().month() : month;
+  let firstDay = (0, import_dayjs.default)().month(monthToUse).startOf("month");
+  while (firstDay.day() === 0 || firstDay.day() === 6) {
+    firstDay = firstDay.add(1, "day");
+  }
+  return firstDay.toDate();
+};
+var getLastWorkdayOfMonth = (month) => {
+  const monthToUse = month === void 0 ? (0, import_dayjs.default)().month() : month;
+  let lastDay = (0, import_dayjs.default)().month(monthToUse).endOf("month");
+  while (lastDay.day() === 0 || lastDay.day() === 6) {
+    lastDay = lastDay.subtract(1, "day");
+  }
+  return lastDay.toDate();
+};
+var getFirstWorkdayAfterMonths = (initialDate, n) => {
+  const startDate = (0, import_dayjs.default)(initialDate);
+  const monthsToAdd = n;
+  const targetDate = startDate.add(monthsToAdd, "months");
+  let firstWorkday = targetDate.startOf("month");
+  while (firstWorkday.day() === 0 || firstWorkday.day() === 6) {
+    firstWorkday = firstWorkday.add(1, "day");
+  }
+  return firstWorkday.toDate();
+};
+var getFirstDayOfYear = () => (0, import_dayjs.default)().startOf("year").toDate();
+var getLastDayOfYear = () => (0, import_dayjs.default)().endOf("year").toDate();
+var isWeekday = (date) => {
+  const d = (0, import_dayjs.default)(date);
+  const dayOfWeek2 = d.day();
+  return dayOfWeek2 !== 0 && dayOfWeek2 !== 6;
+};
+
+// src/objects.ts
+var {
+  isArray,
+  isArrayBuffer,
+  isBoolean,
+  isBuffer,
+  isEqual,
+  isNil,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isString,
+  isTypedArray,
+  transform
+} = lodash;
+var nativeFilter = (array, predicate) => {
+  return array.filter((item) => {
+    return Object.keys(predicate).every((key) => item[key] === predicate[key]);
+  });
+};
+var nativeAssign = (target, source) => {
+  return Object.assign(target, source);
+};
+var nativePick = (object, keys) => {
+  const result = {};
+  keys.forEach((key) => {
+    if (key in object) {
+      result[key] = object[key];
+    }
+  });
+  return result;
+};
+var nativeRemove = (array, predicate) => {
+  const removed = [];
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i])) {
+      removed.unshift(array.splice(i, 1)[0]);
+    }
+  }
+  return removed;
+};
+var comparator = (data1, data2) => isEqual(data1, data2);
+var deepEqual = (data1, data2) => (0, import_fast_deep_equal.default)(data1, data2);
+var formatToReadableString = (data) => JSON.stringify(data).replace(/[{}"]/g, "").replace(/,/g, ", ");
+var getShallowProperties = (obj) => {
+  if (!obj) return {};
+  const topLevelProps = {};
+  for (const prop in obj) {
+    if (Object.hasOwnProperty.call(obj, prop)) {
+      const value = obj[prop];
+      const type = typeof value;
+      if (type !== "object" && type !== "function" || value === null) {
+        topLevelProps[prop] = value;
+      }
+    }
+  }
+  return topLevelProps;
+};
+var calculateDifferences = (oldObj, newObj) => {
+  return transform(
+    newObj,
+    (result, value, key) => {
+      const oldValue = oldObj[key];
+      if (isDateTime(value) && isDateTime(oldValue)) {
+        if (!areDatesEqualWithTolerance(toDate(value), toDate(oldValue))) {
+          result[key] = value;
+        }
+      } else if (!isEqual(value, oldValue)) {
+        result[key] = value;
+      }
+    },
+    {}
+  );
+};
+var generateCrcHash = (str) => {
+  if (isNil(str)) return (0, import_crc32.default)("-").toString(16);
+  if (isString(str)) return (0, import_crc32.default)(str).toString(16);
+  if (isBuffer(str)) return (0, import_crc32.default)(str).toString(16);
+  if (isArrayBuffer(str)) return (0, import_crc32.default)(str).toString(16);
+  if (isBoolean(str)) return (0, import_crc32.default)(str ? "true" : "false").toString(16);
+  if (isNumber(str)) return (0, import_crc32.default)(str.toString()).toString(16);
+  if (isArray(str) || isObject(str)) return generateCrcHash(JSON.stringify(str));
+  return (0, import_crc32.default)(str || "").toString(16);
+};
+var hasSameType = (sourceTarget, destinationTarget) => {
+  if (isArray(sourceTarget) && isArray(destinationTarget)) return true;
+  if (isArray(sourceTarget) !== isArray(destinationTarget)) return false;
+  if (isTypedArray(sourceTarget) && isTypedArray(destinationTarget)) {
+    if (Object.prototype.toString.call(sourceTarget) === Object.prototype.toString.call(destinationTarget))
+      return true;
+    else return false;
+  }
+  if (isTypedArray(sourceTarget) !== isTypedArray(destinationTarget)) return false;
+  if (isPlainObject(sourceTarget) && isPlainObject(destinationTarget)) return true;
+  if (isPlainObject(sourceTarget) !== isPlainObject(destinationTarget)) return false;
+  return typeof sourceTarget === typeof destinationTarget;
+};
+var updateArrayElementsBy = (data, objUpd, objSearch) => {
+  nativeFilter(data, objSearch).forEach((element) => nativeAssign(element, objUpd));
+  return data;
+};
+var updateArrayElementById = (data, objUpd, idField) => {
+  const index = data.findIndex((x) => x[idField] === objUpd[idField]);
+  if (index !== -1) data.splice(index, 1, objUpd);
+};
+var deleteArrayElementsBy = (data, objSearch) => {
+  nativeRemove(data, (x) => deepEqual(nativePick(x, Object.keys(objSearch)), objSearch));
+  return data;
+};
+function setDeepValue(obj, path, value) {
+  if (!obj || typeof obj !== "object") {
+    throw new TypeError("setDeepValue: target must be an object");
+  }
+  if (!path || typeof path !== "string") {
+    throw new TypeError("setDeepValue: path must be a non-empty string");
+  }
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    const nextKey = keys[i + 1];
+    const isNextArray = /^\d+$/.test(nextKey);
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = isNextArray ? [] : {};
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  current[lastKey] = value;
+  return obj;
+}
+function getDeepValue(obj, path, defaultValue) {
+  if (!obj || typeof obj !== "object") {
+    return defaultValue;
+  }
+  if (!path || typeof path !== "string") {
+    return defaultValue;
+  }
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return defaultValue;
+    }
+    if (!(key in current)) {
+      return defaultValue;
+    }
+    current = current[key];
+  }
+  return current !== void 0 ? current : defaultValue;
+}
+
+// src/math.ts
+var math_exports = {};
+__export(math_exports, {
+  calculateAggregations: () => calculateAggregations,
+  calculateAnnuityPayment: () => calculateAnnuityPayment,
+  calculateCorrelation: () => calculateCorrelation,
+  calculateEuclideanDistance: () => calculateEuclideanDistance,
+  calculateFutureValue: () => calculateFutureValue,
+  calculateHistogram: () => calculateHistogram,
+  calculateIQR: () => calculateIQR,
+  calculateIRR: () => calculateIRR,
+  calculateManhattanDistance: () => calculateManhattanDistance,
+  calculateMedian: () => calculateMedian,
+  calculateMode: () => calculateMode,
+  calculateNPV: () => calculateNPV,
+  calculatePercentile: () => calculatePercentile,
+  calculatePresentValue: () => calculatePresentValue,
+  calculateQuartiles: () => calculateQuartiles,
+  calculateStandardDeviation: () => calculateStandardDeviation,
+  calculateTrendSlope: () => calculateTrendSlope,
+  calculateVariance: () => calculateVariance,
+  detectOutliers: () => detectOutliers,
+  normalizeToRange: () => normalizeToRange,
+  scaleToRange: () => scaleToRange,
+  simpleKMeans: () => simpleKMeans
+});
+var lodash2 = __toESM(require("lodash"));
+
+// src/number.ts
+var number_exports = {};
+__export(number_exports, {
+  isNumericValue: () => isNumericValue,
+  roundToDecimals: () => roundToDecimals
+});
+function isNumericValue(value) {
+  if (value === null || value === void 0) return false;
+  if (typeof value === "number") return !isNaN(value) && isFinite(value);
+  if (typeof value === "string") return value.trim() !== "" && !isNaN(Number(value));
+  return false;
+}
+function roundToDecimals(num, decimals = 2) {
+  const factor = Math.pow(10, decimals);
+  return num >= 0 ? Math.round(num * factor) / factor : -Math.round(Math.abs(num) * factor) / factor;
+}
+
+// src/math.ts
+var { map, round, sumBy, get, meanBy, maxBy, some, minBy, uniq, size, sum, zipObject, groupBy } = lodash2;
+var calculateAggregations = (operations, pgroupBy, inData, appendOperationToField = true) => {
+  let data = [];
+  if (pgroupBy?.length) {
+    const groupedData = groupBy(
+      inData,
+      (item) => pgroupBy.map((field) => get(item, field)).join("$|marca|@")
+    );
+    data = map(groupedData, (items, groupKey) => {
+      const obj = zipObject(pgroupBy, groupKey.split("$|marca|@"));
+      for (const operation in operations) {
+        const fields = operations[operation];
+        fields.forEach((field) => {
+          const resultField = appendOperationToField ? field + operation : field;
+          switch (operation) {
+            case "$count":
+              obj[resultField] = items.length;
+              break;
+            case "$sum":
+              obj[resultField] = sumBy(items, (item) => get(item, field));
+              break;
+            case "$avg":
+              obj[resultField] = round(
+                meanBy(items, (item) => get(item, field)),
+                1
+              );
+              break;
+            case "$max": {
+              const maxItem = maxBy(items, (item) => get(item, field));
+              obj[resultField] = maxItem ? get(maxItem, field) : void 0;
+              break;
+            }
+            case "$min": {
+              const minItem = minBy(items, (item) => get(item, field));
+              obj[resultField] = minItem ? get(minItem, field) : void 0;
+              break;
+            }
+            case "$exist":
+              obj[resultField] = some(items, (item) => get(item, field)) ? 1 : 0;
+              break;
+            case "$trend":
+              obj[resultField] = calculateTrendSlope(
+                items.map((item) => get(item, field)),
+                items.map((_item, index) => index + 1)
+              );
+              break;
+            case "$countUniq":
+              obj[resultField] = uniq(items.map((item) => get(item, field))).length;
+              break;
+          }
+        });
+      }
+      return obj;
+    });
+  } else {
+    const results = {};
+    for (const operation in operations) {
+      const fields = operations[operation];
+      fields.forEach((field) => {
+        const resultField = appendOperationToField ? field + operation : field;
+        switch (operation) {
+          case "$count":
+            results[resultField] = inData.length;
+            break;
+          case "$sum":
+            results[resultField] = sumBy(inData, field);
+            break;
+          case "$avg":
+            results[resultField] = round(meanBy(inData, field), 1);
+            break;
+          case "$max":
+            if (Array.isArray(inData)) {
+              const maxItem = maxBy(inData, field);
+              results[resultField] = maxItem ? maxItem[field] : void 0;
+            }
+            break;
+          case "$min":
+            if (Array.isArray(inData)) {
+              const minItem = minBy(inData, field);
+              results[resultField] = minItem ? minItem[field] : void 0;
+            }
+            break;
+          case "$exist":
+            results[resultField] = some(inData, { [field]: true }) ? 1 : 0;
+            break;
+          case "$trend":
+            results[resultField] = calculateTrendSlope(
+              inData.map((item) => get(item, field)),
+              inData.map((_item, index) => index + 1)
+            );
+            break;
+          case "$countUniq":
+            results[resultField] = uniq(inData.map((item) => get(item, field))).length;
+            break;
+        }
+      });
+    }
+    data = results;
+  }
+  return data;
+};
+function calculateTrendSlope(y, x) {
+  const n = size(y);
+  const sum_x = sum(x);
+  const sum_y = sum(y);
+  const sum_x2 = sum(map(x, (val) => val * val));
+  const sum_xy = sum(map(x, (val, i) => val * y[i]));
+  const denominator = n * sum_x2 - sum_x * sum_x;
+  if (denominator === 0) {
+    return 0;
+  }
+  const slope = (n * sum_xy - sum_x * sum_y) / denominator;
+  return roundToDecimals(slope, 1);
+}
+var calculateMedian = (values) => {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return (sorted[middle - 1] + sorted[middle]) / 2;
+  }
+  return sorted[middle];
+};
+var calculateMode = (values) => {
+  if (!values.length) return null;
+  const frequency = {};
+  let maxFreq = 0;
+  let mode = null;
+  let hasMultipleModes = false;
+  for (const value of values) {
+    frequency[value] = (frequency[value] || 0) + 1;
+    if (frequency[value] > maxFreq) {
+      maxFreq = frequency[value];
+      mode = value;
+      hasMultipleModes = false;
+    } else if (frequency[value] === maxFreq && value !== mode) {
+      hasMultipleModes = true;
+    }
+  }
+  return hasMultipleModes ? null : mode;
+};
+var calculateStandardDeviation = (values, sample = false) => {
+  if (!values.length) return 0;
+  const mean = values.reduce((sum2, val) => sum2 + val, 0) / values.length;
+  const squaredDiffs = values.map((val) => Math.pow(val - mean, 2));
+  const variance = squaredDiffs.reduce((sum2, val) => sum2 + val, 0) / (sample ? values.length - 1 : values.length);
+  return Math.sqrt(variance);
+};
+var calculateVariance = (values, sample = false) => {
+  if (!values.length) return 0;
+  const mean = values.reduce((sum2, val) => sum2 + val, 0) / values.length;
+  const squaredDiffs = values.map((val) => Math.pow(val - mean, 2));
+  return squaredDiffs.reduce((sum2, val) => sum2 + val, 0) / (sample ? values.length - 1 : values.length);
+};
+var calculatePercentile = (values, percentile) => {
+  if (!values.length) return 0;
+  if (percentile < 0 || percentile > 100) throw new Error("Percentile must be between 0 and 100");
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = percentile / 100 * (sorted.length - 1);
+  if (Math.floor(index) === index) {
+    return sorted[index];
+  }
+  const lower = sorted[Math.floor(index)];
+  const upper = sorted[Math.ceil(index)];
+  const weight = index - Math.floor(index);
+  return lower * (1 - weight) + upper * weight;
+};
+var calculateQuartiles = (values) => {
+  return {
+    Q1: calculatePercentile(values, 25),
+    Q2: calculatePercentile(values, 50),
+    // median
+    Q3: calculatePercentile(values, 75)
+  };
+};
+var calculateIQR = (values) => {
+  const quartiles = calculateQuartiles(values);
+  return quartiles.Q3 - quartiles.Q1;
+};
+var detectOutliers = (values, multiplier = 1.5) => {
+  const quartiles = calculateQuartiles(values);
+  const iqr = quartiles.Q3 - quartiles.Q1;
+  const lowerBound = quartiles.Q1 - multiplier * iqr;
+  const upperBound = quartiles.Q3 + multiplier * iqr;
+  return values.filter((value) => value < lowerBound || value > upperBound);
+};
+var calculateCorrelation = (x, y) => {
+  if (x.length !== y.length || x.length === 0) return 0;
+  const n = x.length;
+  const sumX = sum(x);
+  const sumY = sum(y);
+  const sumXY = sum(map(x, (val, i) => val * y[i]));
+  const sumX2 = sum(map(x, (val) => val * val));
+  const sumY2 = sum(map(y, (val) => val * val));
+  const numerator = n * sumXY - sumX * sumY;
+  const denominator = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
+  if (denominator === 0) return 0;
+  return numerator / denominator;
+};
+var calculateNPV = (cashFlows, discountRate) => {
+  return cashFlows.reduce((npv, cashFlow, index) => {
+    const discountFactor = index === 0 ? 1 : Math.pow(1 + discountRate, index);
+    return npv + cashFlow / discountFactor;
+  }, 0);
+};
+var calculateIRR = (cashFlows, initialGuess = 0.1, maxIterations = 100, tolerance = 1e-6) => {
+  let rate = initialGuess;
+  for (let i = 0; i < maxIterations; i++) {
+    const npv = calculateNPV(cashFlows, rate);
+    const npvDerivative = cashFlows.reduce((sum2, cashFlow, index) => {
+      return sum2 - index * cashFlow / Math.pow(1 + rate, index + 1);
+    }, 0);
+    if (Math.abs(npv) < tolerance) return rate;
+    if (Math.abs(npvDerivative) < tolerance) break;
+    rate = rate - npv / npvDerivative;
+  }
+  return rate;
+};
+var calculateFutureValue = (presentValue, interestRate, periods) => {
+  return presentValue * Math.pow(1 + interestRate, periods);
+};
+var calculatePresentValue = (futureValue, interestRate, periods) => {
+  return futureValue / Math.pow(1 + interestRate, periods);
+};
+var calculateAnnuityPayment = (presentValue, interestRate, periods) => {
+  if (interestRate === 0) return presentValue / periods;
+  return presentValue * (interestRate * Math.pow(1 + interestRate, periods)) / (Math.pow(1 + interestRate, periods) - 1);
+};
+var normalizeToRange = (values) => {
+  if (!values.length) return [];
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min;
+  if (range === 0) return values.map(() => 0);
+  return values.map((value) => (value - min) / range);
+};
+var scaleToRange = (values, minRange, maxRange) => {
+  const normalized = normalizeToRange(values);
+  const scale = maxRange - minRange;
+  return normalized.map((value) => minRange + value * scale);
+};
+var calculateHistogram = (values, bins) => {
+  if (!values.length || bins <= 0) return [];
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const binWidth = (max - min) / bins;
+  const histogram = [];
+  for (let i = 0; i < bins; i++) {
+    const rangeStart = min + i * binWidth;
+    const rangeEnd = i === bins - 1 ? max : rangeStart + binWidth;
+    const count = values.filter(
+      (value) => value >= rangeStart && (i === bins - 1 ? value <= rangeEnd : value < rangeEnd)
+    ).length;
+    histogram.push({
+      range: [roundToDecimals(rangeStart, 2), roundToDecimals(rangeEnd, 2)],
+      count
+    });
+  }
+  return histogram;
+};
+var calculateEuclideanDistance = (point1, point2) => {
+  if (point1.length !== point2.length) {
+    throw new Error("Points must have the same number of dimensions");
+  }
+  const squaredDiffs = point1.map((val, index) => Math.pow(val - point2[index], 2));
+  return Math.sqrt(sum(squaredDiffs));
+};
+var calculateManhattanDistance = (point1, point2) => {
+  if (point1.length !== point2.length) {
+    throw new Error("Points must have the same number of dimensions");
+  }
+  return sum(point1.map((val, index) => Math.abs(val - point2[index])));
+};
+var simpleKMeans = (points, k, maxIterations = 100) => {
+  if (points.length === 0 || k <= 0) {
+    return { centroids: [], clusters: [] };
+  }
+  const dimensions = points[0].length;
+  let centroids = [];
+  for (let i = 0; i < k; i++) {
+    const randomPoint = points[Math.floor(Math.random() * points.length)];
+    centroids.push([...randomPoint]);
+  }
+  const clusters = new Array(points.length);
+  for (let iteration = 0; iteration < maxIterations; iteration++) {
+    let hasChanged = false;
+    for (let i = 0; i < points.length; i++) {
+      let minDistance = Infinity;
+      let closestCentroid = 0;
+      for (let j = 0; j < centroids.length; j++) {
+        const distance = calculateEuclideanDistance(points[i], centroids[j]);
+        if (distance < minDistance) {
+          minDistance = distance;
+          closestCentroid = j;
+        }
+      }
+      if (clusters[i] !== closestCentroid) {
+        hasChanged = true;
+        clusters[i] = closestCentroid;
+      }
+    }
+    const newCentroids = new Array(k).fill(0).map(() => new Array(dimensions).fill(0));
+    const clusterCounts = new Array(k).fill(0);
+    for (let i = 0; i < points.length; i++) {
+      const cluster = clusters[i];
+      clusterCounts[cluster]++;
+      for (let dim = 0; dim < dimensions; dim++) {
+        newCentroids[cluster][dim] += points[i][dim];
+      }
+    }
+    for (let i = 0; i < k; i++) {
+      if (clusterCounts[i] > 0) {
+        for (let dim = 0; dim < dimensions; dim++) {
+          newCentroids[i][dim] /= clusterCounts[i];
+        }
+      }
+    }
+    centroids = newCentroids;
+    if (!hasChanged) break;
+  }
+  return { centroids, clusters };
+};
+
+// src/async.ts
+var async_exports = {};
+__export(async_exports, {
+  handleOperation: () => handleOperation,
+  runBatch: () => runBatch,
+  sleep: () => sleep,
+  wait: () => wait
+});
+
+// src/errors.ts
+var TsHelpersError = class _TsHelpersError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "TsHelpersError";
+    this.code = options.code;
+    this.data = options.data;
+    this.cause = options.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _TsHelpersError);
+    }
+  }
+};
+
+// src/async.ts
+var sleep = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+var wait = (ms) => sleep(ms);
+async function runBatch(jobs, batchSize = 50) {
+  if (batchSize <= 0) {
+    throw new TsHelpersError("Batch size must be greater than 0", {
+      code: "INVALID_OPERATION" /* INVALID_OPERATION */,
+      data: { batchSize }
+    });
+  }
+  const results = [];
+  const batches = Math.ceil(jobs.length / batchSize);
+  for (let i = 0; i < batches; i++) {
+    const batchStart = i * batchSize;
+    const batchEnd = batchStart + batchSize;
+    const batch = jobs.slice(batchStart, batchEnd);
+    const batchResults = await Promise.all(batch.map((job) => job));
+    results.push(...batchResults);
+  }
+  return results;
+}
+function handleOperation(target, operation, ...args) {
+  if (operation.includes("/")) {
+    const [parentOp, childOp] = operation.split("/");
+    if (!target[parentOp] || !target[parentOp][childOp]) {
+      throw new TsHelpersError(`Operation [${operation}] does not exist`, {
+        code: "INVALID_OPERATION" /* INVALID_OPERATION */,
+        data: { operation, parentOp, childOp }
+      });
+    }
+    return target[parentOp][childOp](...args);
+  }
+  if (!target[operation]) {
+    throw new TsHelpersError(`Operation [${operation}] does not exist`, {
+      code: "INVALID_OPERATION" /* INVALID_OPERATION */,
+      data: { operation }
+    });
+  }
+  return target[operation](...args);
+}
+
+// src/universal/index.ts
+var g = {
+  // Core validation functions (no crypto)
+  ...validation_core_exports,
+  // String functions
+  ...strings_exports,
+  // Object/Array functions
+  ...objects_exports,
+  // Date functions
+  ...dates_exports,
+  // Math functions
+  ...math_exports,
+  // Async functions
+  ...async_exports,
+  // Number utilities
+  ...number_exports,
+  // Environment utilities (original)
+  ...environment_exports,
+  // Enhanced environment detection
+  ...environment_detection_exports
+};
+var universal_default = g;
+//# sourceMappingURL=index.js.map