@gzl10/ts-helpers 4.2.1

package/dist/node/index.js

@@ -0,0 +1,3151 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/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;
+}
+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;
+}
+var isNode, isBrowser;
+var init_environment = __esm({
+  "src/environment.ts"() {
+    "use strict";
+    isNode = isNodeEnvironment;
+    isBrowser = isBrowserEnvironment;
+  }
+});
+
+// src/tree.ts
+var tree_exports = {};
+__export(tree_exports, {
+  renderTreeAsText: () => renderTreeAsText
+});
+function renderTreeAsText(data, options) {
+  if (!data || !Array.isArray(data)) {
+    return "";
+  }
+  if (data.length === 0) {
+    return "";
+  }
+  const {
+    labelField = "name",
+    verticalLine = "\u2502   ",
+    middleBranch = "\u251C\u2500\u2500 ",
+    lastBranch = "\u2514\u2500\u2500 ",
+    emptySpace = "    ",
+    labelFunction
+  } = options || {};
+  const visited = /* @__PURE__ */ new WeakSet();
+  const getLabel = (node) => {
+    try {
+      if (labelFunction) return String(labelFunction(node));
+      if (node == null) return "[null]";
+      if (typeof node !== "object") return String(node);
+      return node[labelField] != null ? String(node[labelField]) : String(node);
+    } catch (_error) {
+      return "[error]";
+    }
+  };
+  const renderNode = (node, prefix = "", isLast = true, depth = 0) => {
+    if (node == null) {
+      return "";
+    }
+    if (typeof node === "object" && visited.has(node)) {
+      return `${prefix + (isLast ? lastBranch : middleBranch)}[circular reference]`;
+    }
+    if (depth > 100) {
+      return `${prefix + (isLast ? lastBranch : middleBranch)}[max depth exceeded]`;
+    }
+    if (typeof node === "object") {
+      visited.add(node);
+    }
+    const lines = [];
+    const currentPrefix = isLast ? lastBranch : middleBranch;
+    lines.push(prefix + currentPrefix + getLabel(node));
+    const children = Array.isArray(node.children) ? node.children.filter((child) => child != null) : [];
+    const nextPrefix = prefix + (isLast ? emptySpace : verticalLine);
+    children.forEach((child, index) => {
+      const isLastChild = index === children.length - 1;
+      const childOutput = renderNode(child, nextPrefix, isLastChild, depth + 1);
+      if (childOutput) {
+        lines.push(childOutput);
+      }
+    });
+    return lines.join("\n");
+  };
+  const validRoots = data.filter((root) => root != null);
+  if (validRoots.length === 0) {
+    return "";
+  }
+  return validRoots.map((root, index) => renderNode(root, "", index === validRoots.length - 1)).join("\n");
+}
+var init_tree = __esm({
+  "src/tree.ts"() {
+    "use strict";
+  }
+});
+
+// src/validators.ts
+var validators_exports = {};
+__export(validators_exports, {
+  isValidFilePath: () => isValidFilePath,
+  isValidFileSize: () => isValidFileSize,
+  isValidTextContent: () => isValidTextContent
+});
+function isValidFilePath(filePath) {
+  if (!filePath || typeof filePath !== "string") return false;
+  if (typeof filePath === "object") return false;
+  if (filePath.length === 0 || filePath.length > 1e3) return false;
+  if (filePath.includes("../") || filePath.includes("..\\")) return false;
+  const suspiciousPatterns = ["//", "\\\\", "//\\", "\\//", "/./", "\\.\\"];
+  if (suspiciousPatterns.some((pattern) => filePath.includes(pattern))) return false;
+  const encodedPatterns = [
+    "%2e%2e%2f",
+    // ../
+    "%2e%2e/",
+    // ../
+    "%2e%2e%5c",
+    // ..\
+    "%252e"
+    // double-encoded
+  ];
+  if (encodedPatterns.some((pattern) => filePath.toLowerCase().includes(pattern))) return false;
+  if (filePath.includes("\0")) return false;
+  const commandChars = [";", "&", "|", "`", "$", "(", ")", "{", "}"];
+  if (commandChars.some((char) => filePath.includes(char))) return false;
+  const sqlPatterns = ["'", '"', "--", "/*", "*/", "DROP", "DELETE", "UNION", "SELECT"];
+  const lowerPath = filePath.toLowerCase();
+  if (sqlPatterns.some(
+    (pattern) => lowerPath.includes(pattern.toLowerCase()) && (pattern === "'" || pattern === '"' || lowerPath.includes(` ${pattern.toLowerCase()}`))
+  ))
+    return false;
+  const dangerousUnicode = [
+    "\u202E",
+    // Right-to-left override
+    "\u200B",
+    // Zero-width space
+    "\u200C",
+    // Zero-width non-joiner
+    "\u200D",
+    // Zero-width joiner
+    "\uFEFF"
+    // Zero-width no-break space
+  ];
+  if (dangerousUnicode.some((char) => filePath.includes(char))) return false;
+  if (/^[A-Za-z]:\\.*\\\.\./.test(filePath)) return false;
+  return true;
+}
+function isValidFileSize(size2, maxSize) {
+  return typeof size2 === "number" && size2 >= 0 && size2 <= maxSize;
+}
+function isValidTextContent(content, options = {}) {
+  const { maxLength = 1e6 } = options;
+  if (typeof content !== "string") return false;
+  if (content.length > maxLength) return false;
+  const lowerContent = content.toLowerCase();
+  const scriptPatterns = ["<script", "</script", "<scr<script>ipt", "<scr\0ipt"];
+  if (scriptPatterns.some((pattern) => lowerContent.includes(pattern))) return false;
+  const eventHandlers = [
+    "onerror",
+    "onload",
+    "onclick",
+    "onmouseover",
+    "onfocus",
+    "onblur",
+    "oninput"
+  ];
+  if (eventHandlers.some((handler) => lowerContent.includes(handler))) return false;
+  const protocolPatterns = [
+    "javascript:",
+    "data:text/html",
+    "data:text/javascript",
+    "data:application",
+    "vbscript:",
+    "file:///",
+    "steam://",
+    "slack://"
+  ];
+  if (protocolPatterns.some((pattern) => lowerContent.includes(pattern))) return false;
+  const encodedPatterns = [
+    "&#60;script",
+    // &#60; = <
+    "%3cscript",
+    // %3c = <
+    "\\x3cscript",
+    // \x3c = <
+    "\\u003cscript"
+    // \u003c = <
+  ];
+  if (encodedPatterns.some((pattern) => lowerContent.includes(pattern))) return false;
+  if (lowerContent.includes("<svg") && lowerContent.includes("onload")) return false;
+  if (lowerContent.includes("<iframe")) return false;
+  return true;
+}
+var init_validators = __esm({
+  "src/validators.ts"() {
+    "use strict";
+  }
+});
+
+// src/csv.ts
+var csv_exports = {};
+__export(csv_exports, {
+  exportCSV: () => exportCSV,
+  importCSV: () => importCSV
+});
+async function exportCSV(data, filePath, options) {
+  if (data == null) {
+    throw new TypeError("Data cannot be null or undefined");
+  }
+  if (!Array.isArray(data)) {
+    throw new TypeError("Data must be an array");
+  }
+  if (data.length === 0) {
+    throw new Error("Data array cannot be empty");
+  }
+  if (!filePath || typeof filePath !== "string" || filePath.trim() === "") {
+    throw new TypeError("File path must be a non-empty string");
+  }
+  const csvText = import_papaparse.default.unparse(data, {
+    delimiter: ";",
+    header: true,
+    ...options
+  });
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, `\uFEFF${csvText}`, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([`\uFEFF${csvText}`], { type: "text/csv;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "data.csv";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+async function importCSV(filePath, options) {
+  if (!filePath || typeof filePath !== "string" || filePath.trim() === "") {
+    throw new TypeError("File path must be a non-empty string");
+  }
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    const content = await fs.readFile(filePath, { encoding: "utf-8" });
+    const parseResult = import_papaparse.default.parse(content, {
+      header: true,
+      delimiter: ";",
+      skipEmptyLines: true,
+      ...options
+    });
+    return parseResult.data || [];
+  } else {
+    throw new Error("CSV import not supported in browser. Use readFileAsText() with a File object.");
+  }
+}
+var import_papaparse;
+var init_csv = __esm({
+  "src/csv.ts"() {
+    "use strict";
+    import_papaparse = __toESM(require("papaparse"));
+    init_environment();
+  }
+});
+
+// src/json.ts
+var json_exports = {};
+__export(json_exports, {
+  exportJSON: () => exportJSON,
+  importJSON: () => importJSON
+});
+async function exportJSON(data, filePath, options) {
+  if (data === null || data === void 0) {
+    throw new TypeError("Data cannot be null or undefined");
+  }
+  if (!filePath || typeof filePath !== "string" || filePath.trim() === "") {
+    throw new TypeError("File path must be a non-empty string");
+  }
+  const { indent = 2 } = options || {};
+  let jsonText;
+  try {
+    jsonText = JSON.stringify(data, null, indent);
+  } catch (error) {
+    if (error instanceof TypeError && error.message.includes("circular")) {
+      throw new TypeError("Cannot serialize data with circular references");
+    }
+    throw error;
+  }
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, jsonText, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([jsonText], { type: "application/json;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "data.json";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+async function importJSON(filePath, _options) {
+  if (!filePath || typeof filePath !== "string" || filePath.trim() === "") {
+    throw new TypeError("File path must be a non-empty string");
+  }
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    const content = await fs.readFile(filePath, { encoding: "utf-8" });
+    const trimmed = content.trim();
+    if (trimmed === "") {
+      throw new SyntaxError("JSON file is empty");
+    }
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new SyntaxError(`Invalid JSON in file ${filePath}: ${error.message}`);
+      }
+      throw error;
+    }
+  } else {
+    throw new Error(
+      "JSON import not supported in browser. Use readFileAsText() with a File object."
+    );
+  }
+}
+var init_json = __esm({
+  "src/json.ts"() {
+    "use strict";
+    init_environment();
+  }
+});
+
+// src/node/index.ts
+var node_exports = {};
+__export(node_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,
+  data: () => data_exports,
+  dates: () => dates_exports,
+  dayOfWeek: () => dayOfWeek,
+  deepEqual: () => deepEqual,
+  default: () => node_default,
+  deleteArrayElementsBy: () => deleteArrayElementsBy,
+  detectFileExtension: () => detectFileExtension,
+  detectFormatFromFilename: () => detectFormatFromFilename,
+  detectHostname: () => detectHostname,
+  detectOutliers: () => detectOutliers,
+  detectProtocol: () => detectProtocol,
+  detectUniversalFormat: () => detectUniversalFormat,
+  diffBusinessDays: () => diffBusinessDays,
+  diffDays: () => diffDays,
+  diffMilliSeconds: () => diffMilliSeconds,
+  diffMonths: () => diffMonths,
+  diffYears: () => diffYears,
+  endsWith: () => endsWith,
+  ensureEndsWith: () => ensureEndsWith,
+  ensureStartsWith: () => ensureStartsWith,
+  envKeyToPath: () => envKeyToPath,
+  environment: () => environment_exports,
+  escapeHtmlChars: () => escapeHtmlChars,
+  escapeShellCommand: () => escapeShellCommand,
+  excelToDate: () => excelToDate,
+  exportData: () => exportData,
+  exportTree: () => exportTree,
+  exportTxt: () => exportTxt,
+  format: () => format,
+  formatForMysql: () => formatForMysql,
+  formatNow: () => formatNow,
+  formatToReadableString: () => formatToReadableString,
+  fromNow: () => fromNow,
+  generateAlphaNumericString: () => generateAlphaNumericString,
+  generateAlphaString: () => generateAlphaString,
+  generateComplexString: () => generateComplexString,
+  generateCrcHash: () => generateCrcHash,
+  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,
+  getDeepValue: () => getDeepValue,
+  getEnvironmentInfo: () => getEnvironmentInfo,
+  getFirstDayOfYear: () => getFirstDayOfYear,
+  getFirstWorkdayAfterMonths: () => getFirstWorkdayAfterMonths,
+  getFirstWorkdayOfMonth: () => getFirstWorkdayOfMonth,
+  getLastDayOfYear: () => getLastDayOfYear,
+  getLastWorkdayOfMonth: () => getLastWorkdayOfMonth,
+  getShallowProperties: () => getShallowProperties,
+  handleOperation: () => handleOperation,
+  hasSameType: () => hasSameType,
+  hashString: () => hashString,
+  importData: () => importData,
+  importTree: () => importTree,
+  importTxt: () => importTxt,
+  isBrowser: () => isBrowser,
+  isBrowserEnvironment: () => isBrowserEnvironment,
+  isDateTime: () => isDateTime,
+  isDevelopment: () => isDevelopment,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  isEqualsDateTimeByDay: () => isEqualsDateTimeByDay,
+  isExpired: () => isExpired,
+  isLocalhost: () => isLocalhost,
+  isNew: () => isNew,
+  isNode: () => isNode,
+  isNodeEnvironment: () => isNodeEnvironment,
+  isNonProduction: () => isNonProduction,
+  isNumericValue: () => isNumericValue,
+  isPrivateIP: () => isPrivateIP,
+  isProduction: () => isProduction,
+  isSecureUrl: () => isSecureUrl,
+  isTest: () => isTest,
+  isValidBase64: () => isValidBase64,
+  isValidCIF: () => isValidCIF,
+  isValidEmail: () => isValidEmail,
+  isValidJSON: () => isValidJSON,
+  isValidJWTFormat: () => isValidJWTFormat,
+  isValidNIE: () => isValidNIE,
+  isValidNIF: () => isValidNIF,
+  isValidSpanishIBAN: () => isValidSpanishIBAN,
+  isValidSpanishPhone: () => isValidSpanishPhone,
+  isValidSpanishPostalCode: () => isValidSpanishPostalCode,
+  isValidURL: () => isValidURL,
+  isWeekday: () => isWeekday,
+  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,
+  readFileAsText: () => readFileAsText,
+  removeAccents: () => removeAccents,
+  removeDangerousChars: () => removeDangerousChars,
+  renderTreeAsText: () => renderTreeAsText,
+  repeatString: () => repeatString,
+  replaceAllOccurrences: () => replaceAllOccurrences,
+  reverseString: () => reverseString,
+  roundToDecimals: () => roundToDecimals,
+  runBatch: () => runBatch,
+  sanitizeHtml: () => sanitizeHtml,
+  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,
+  tree: () => tree_exports,
+  trim: () => trim,
+  trimEnd: () => trimEnd,
+  trimStart: () => trimStart,
+  truncateString: () => truncateString,
+  unescapeHtmlChars: () => unescapeHtmlChars,
+  unescapeUnicode: () => unescapeUnicode,
+  updateArrayElementById: () => updateArrayElementById,
+  updateArrayElementsBy: () => updateArrayElementsBy,
+  validateCSVData: () => validateCSVData,
+  validateExportData: () => validateExportData,
+  validateNIF: () => validateNIF,
+  validatePassword: () => validatePassword,
+  validation: () => validationFunctions,
+  wait: () => wait,
+  weekOfYear: () => weekOfYear
+});
+module.exports = __toCommonJS(node_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/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);
+    }
+  }
+};
+var DataError = class extends TsHelpersError {
+  constructor(message, code, data) {
+    super(message, { code, data });
+    this.name = "DataError";
+  }
+};
+function createValidationError(message, field, value) {
+  return new TsHelpersError(`Validation failed: ${message}`, {
+    code: "VALIDATION_FAILED" /* VALIDATION_FAILED */,
+    data: { field, value }
+  });
+}
+
+// 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/data.ts
+var data_exports = {};
+__export(data_exports, {
+  detectFileExtension: () => detectFileExtension,
+  detectFormatFromFilename: () => detectFormatFromFilename,
+  detectUniversalFormat: () => detectUniversalFormat,
+  exportData: () => exportData,
+  exportTree: () => exportTree,
+  exportTxt: () => exportTxt,
+  importData: () => importData,
+  importTree: () => importTree,
+  importTxt: () => importTxt,
+  readFileAsText: () => readFileAsText,
+  validateCSVData: () => validateCSVData,
+  validateExportData: () => validateExportData
+});
+init_environment();
+var readFileAsText = async (fileOrPath, encoding = "utf8") => {
+  if (isNode() && typeof fileOrPath === "string") {
+    const fs = await import("fs/promises");
+    return fs.readFile(fileOrPath, encoding);
+  } else if (isBrowser() && fileOrPath instanceof File) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = (e) => resolve(e.target?.result);
+      reader.onerror = () => reject(new Error("Error reading file"));
+      reader.readAsText(fileOrPath);
+    });
+  } else {
+    throw new DataError(
+      "Invalid parameter for current environment",
+      "ENVIRONMENT_NOT_SUPPORTED" /* ENVIRONMENT_NOT_SUPPORTED */,
+      {
+        data: {
+          isNodeEnv: isNode(),
+          isBrowserEnv: isBrowser(),
+          parameterType: typeof fileOrPath
+        }
+      }
+    );
+  }
+};
+function validateExportData(data) {
+  if (!Array.isArray(data)) {
+    throw createValidationError("Data must be an array", "data", typeof data);
+  }
+  if (data.length === 0) {
+    throw createValidationError("Data array cannot be empty", "data.length", data.length);
+  }
+  const firstItem = data[0];
+  const isObjectArray = typeof firstItem === "object" && firstItem !== null && !Array.isArray(firstItem);
+  const isArrayOfArrays = Array.isArray(firstItem);
+  if (!isObjectArray && !isArrayOfArrays) {
+    throw createValidationError(
+      "Data must be an array of objects or an array of arrays",
+      "data[0]",
+      typeof firstItem
+    );
+  }
+  if (isObjectArray) {
+    for (let i = 1; i < data.length; i++) {
+      const item = data[i];
+      if (typeof item !== "object" || item === null || Array.isArray(item)) {
+        throw createValidationError(
+          "All elements must be objects if first one is an object",
+          `data[${i}]`,
+          typeof item
+        );
+      }
+    }
+  } else if (isArrayOfArrays) {
+    const firstRowLength = firstItem.length;
+    for (let i = 1; i < data.length; i++) {
+      if (!Array.isArray(data[i])) {
+        throw createValidationError(`Row ${i} is not an array`, `data[${i}]`, typeof data[i]);
+      }
+      if (data[i].length !== firstRowLength) {
+        throw createValidationError(
+          `Row ${i} has ${data[i].length} columns, but first has ${firstRowLength}`,
+          `data[${i}].length`,
+          { expected: firstRowLength, actual: data[i].length }
+        );
+      }
+    }
+  }
+  return true;
+}
+var validateCSVData = validateExportData;
+function detectFormatFromFilename(filename) {
+  const parts = filename.toLowerCase().split(".");
+  const extension = parts.length > 1 ? parts.pop() : void 0;
+  switch (extension) {
+    case "csv":
+      return "csv";
+    case "json":
+      return "json";
+    case "tree":
+      return "tree";
+    case "txt":
+      return "txt";
+    default:
+      if (!extension) {
+        throw new DataError(
+          "Could not detect file format. Must have a valid extension (.csv, .json, .tree, .txt)",
+          "UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */,
+          { data: { filename } }
+        );
+      }
+      throw new DataError(
+        `Unsupported file format: .${extension}. Use .csv, .json, .tree or .txt`,
+        "UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */,
+        { data: { filename, extension } }
+      );
+  }
+}
+function detectFileExtension(filename) {
+  if (!filename || typeof filename !== "string") {
+    return null;
+  }
+  const parts = filename.trim().split(".");
+  if (parts.length < 2) {
+    return null;
+  }
+  const extension = parts.pop()?.toLowerCase();
+  return extension || null;
+}
+function detectUniversalFormat(filename) {
+  const extension = detectFileExtension(filename);
+  if (!extension) {
+    return {
+      extension: null,
+      category: "unknown",
+      isText: false,
+      isBinary: false,
+      mimeType: null
+    };
+  }
+  const formatInfo = {
+    // Data formats
+    json: { category: "data", isText: true, isBinary: false, mimeType: "application/json" },
+    csv: { category: "data", isText: true, isBinary: false, mimeType: "text/csv" },
+    xml: { category: "data", isText: true, isBinary: false, mimeType: "application/xml" },
+    yaml: { category: "data", isText: true, isBinary: false, mimeType: "application/yaml" },
+    yml: { category: "data", isText: true, isBinary: false, mimeType: "application/yaml" },
+    tree: { category: "data", isText: true, isBinary: false, mimeType: "text/plain" },
+    tsv: { category: "data", isText: true, isBinary: false, mimeType: "text/tab-separated-values" },
+    sql: { category: "data", isText: true, isBinary: false, mimeType: "application/sql" },
+    db: { category: "data", isText: false, isBinary: true, mimeType: "application/x-sqlite3" },
+    sqlite: { category: "data", isText: false, isBinary: true, mimeType: "application/x-sqlite3" },
+    // Text and code formats
+    txt: { category: "text", isText: true, isBinary: false, mimeType: "text/plain" },
+    md: { category: "text", isText: true, isBinary: false, mimeType: "text/markdown" },
+    rst: { category: "text", isText: true, isBinary: false, mimeType: "text/x-rst" },
+    rtf: { category: "text", isText: true, isBinary: false, mimeType: "application/rtf" },
+    log: { category: "text", isText: true, isBinary: false, mimeType: "text/plain" },
+    // Web formats
+    html: { category: "web", isText: true, isBinary: false, mimeType: "text/html" },
+    htm: { category: "web", isText: true, isBinary: false, mimeType: "text/html" },
+    css: { category: "web", isText: true, isBinary: false, mimeType: "text/css" },
+    scss: { category: "web", isText: true, isBinary: false, mimeType: "text/x-scss" },
+    sass: { category: "web", isText: true, isBinary: false, mimeType: "text/x-sass" },
+    less: { category: "web", isText: true, isBinary: false, mimeType: "text/x-less" },
+    // Programming languages
+    js: { category: "code", isText: true, isBinary: false, mimeType: "application/javascript" },
+    mjs: { category: "code", isText: true, isBinary: false, mimeType: "application/javascript" },
+    jsx: { category: "code", isText: true, isBinary: false, mimeType: "text/jsx" },
+    ts: { category: "code", isText: true, isBinary: false, mimeType: "application/typescript" },
+    tsx: { category: "code", isText: true, isBinary: false, mimeType: "text/tsx" },
+    py: { category: "code", isText: true, isBinary: false, mimeType: "text/x-python" },
+    java: { category: "code", isText: true, isBinary: false, mimeType: "text/x-java-source" },
+    php: { category: "code", isText: true, isBinary: false, mimeType: "application/x-httpd-php" },
+    rb: { category: "code", isText: true, isBinary: false, mimeType: "text/x-ruby" },
+    go: { category: "code", isText: true, isBinary: false, mimeType: "text/x-go" },
+    rs: { category: "code", isText: true, isBinary: false, mimeType: "text/x-rust" },
+    c: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c" },
+    cpp: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c++" },
+    cc: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c++" },
+    h: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c" },
+    cs: { category: "code", isText: true, isBinary: false, mimeType: "text/x-csharp" },
+    sh: { category: "code", isText: true, isBinary: false, mimeType: "application/x-sh" },
+    bash: { category: "code", isText: true, isBinary: false, mimeType: "application/x-sh" },
+    ps1: { category: "code", isText: true, isBinary: false, mimeType: "application/x-powershell" },
+    // Microsoft Office documents
+    doc: { category: "document", isText: false, isBinary: true, mimeType: "application/msword" },
+    docx: {
+      category: "document",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    },
+    xls: {
+      category: "spreadsheet",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.ms-excel"
+    },
+    xlsx: {
+      category: "spreadsheet",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    },
+    ppt: {
+      category: "presentation",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.ms-powerpoint"
+    },
+    pptx: {
+      category: "presentation",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    },
+    // LibreOffice/OpenOffice
+    odt: {
+      category: "document",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.oasis.opendocument.text"
+    },
+    ods: {
+      category: "spreadsheet",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.oasis.opendocument.spreadsheet"
+    },
+    odp: {
+      category: "presentation",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.oasis.opendocument.presentation"
+    },
+    // Other document formats
+    pdf: { category: "document", isText: false, isBinary: true, mimeType: "application/pdf" },
+    epub: { category: "document", isText: false, isBinary: true, mimeType: "application/epub+zip" },
+    mobi: {
+      category: "document",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/x-mobipocket-ebook"
+    },
+    // Image formats
+    jpg: { category: "image", isText: false, isBinary: true, mimeType: "image/jpeg" },
+    jpeg: { category: "image", isText: false, isBinary: true, mimeType: "image/jpeg" },
+    png: { category: "image", isText: false, isBinary: true, mimeType: "image/png" },
+    gif: { category: "image", isText: false, isBinary: true, mimeType: "image/gif" },
+    svg: { category: "image", isText: true, isBinary: false, mimeType: "image/svg+xml" },
+    webp: { category: "image", isText: false, isBinary: true, mimeType: "image/webp" },
+    avif: { category: "image", isText: false, isBinary: true, mimeType: "image/avif" },
+    bmp: { category: "image", isText: false, isBinary: true, mimeType: "image/bmp" },
+    tiff: { category: "image", isText: false, isBinary: true, mimeType: "image/tiff" },
+    tif: { category: "image", isText: false, isBinary: true, mimeType: "image/tiff" },
+    ico: { category: "image", isText: false, isBinary: true, mimeType: "image/x-icon" },
+    psd: {
+      category: "image",
+      isText: false,
+      isBinary: true,
+      mimeType: "image/vnd.adobe.photoshop"
+    },
+    // Audio formats
+    mp3: { category: "audio", isText: false, isBinary: true, mimeType: "audio/mpeg" },
+    wav: { category: "audio", isText: false, isBinary: true, mimeType: "audio/wav" },
+    flac: { category: "audio", isText: false, isBinary: true, mimeType: "audio/flac" },
+    ogg: { category: "audio", isText: false, isBinary: true, mimeType: "audio/ogg" },
+    aac: { category: "audio", isText: false, isBinary: true, mimeType: "audio/aac" },
+    m4a: { category: "audio", isText: false, isBinary: true, mimeType: "audio/m4a" },
+    wma: { category: "audio", isText: false, isBinary: true, mimeType: "audio/x-ms-wma" },
+    // Video formats
+    mp4: { category: "video", isText: false, isBinary: true, mimeType: "video/mp4" },
+    avi: { category: "video", isText: false, isBinary: true, mimeType: "video/x-msvideo" },
+    mov: { category: "video", isText: false, isBinary: true, mimeType: "video/quicktime" },
+    wmv: { category: "video", isText: false, isBinary: true, mimeType: "video/x-ms-wmv" },
+    flv: { category: "video", isText: false, isBinary: true, mimeType: "video/x-flv" },
+    webm: { category: "video", isText: false, isBinary: true, mimeType: "video/webm" },
+    mkv: { category: "video", isText: false, isBinary: true, mimeType: "video/x-matroska" },
+    "3gp": { category: "video", isText: false, isBinary: true, mimeType: "video/3gpp" },
+    // Archive formats
+    zip: { category: "archive", isText: false, isBinary: true, mimeType: "application/zip" },
+    rar: {
+      category: "archive",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/x-rar-compressed"
+    },
+    "7z": {
+      category: "archive",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/x-7z-compressed"
+    },
+    tar: { category: "archive", isText: false, isBinary: true, mimeType: "application/x-tar" },
+    gz: { category: "archive", isText: false, isBinary: true, mimeType: "application/gzip" },
+    bz2: { category: "archive", isText: false, isBinary: true, mimeType: "application/x-bzip2" },
+    xz: { category: "archive", isText: false, isBinary: true, mimeType: "application/x-xz" },
+    // Configuration files
+    ini: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    cfg: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    conf: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    toml: { category: "config", isText: true, isBinary: false, mimeType: "application/toml" },
+    env: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    // Font formats
+    ttf: { category: "font", isText: false, isBinary: true, mimeType: "font/ttf" },
+    otf: { category: "font", isText: false, isBinary: true, mimeType: "font/otf" },
+    woff: { category: "font", isText: false, isBinary: true, mimeType: "font/woff" },
+    woff2: { category: "font", isText: false, isBinary: true, mimeType: "font/woff2" },
+    eot: {
+      category: "font",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.ms-fontobject"
+    }
+  };
+  const info = formatInfo[extension] || {
+    category: "unknown",
+    isText: false,
+    isBinary: false,
+    mimeType: null
+  };
+  return {
+    extension,
+    ...info
+  };
+}
+async function exportTree(data, filePath, options) {
+  if (!Array.isArray(data)) {
+    throw createValidationError(
+      "Data for tree format must be an array of nodes",
+      "data",
+      typeof data
+    );
+  }
+  const { renderTreeAsText: renderTreeAsText2 } = await Promise.resolve().then(() => (init_tree(), tree_exports));
+  const treeText = renderTreeAsText2(data, options);
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, treeText, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([treeText], { type: "text/plain;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "tree.tree";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+async function importTree(filePath, _options) {
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    return fs.readFile(filePath, { encoding: "utf-8" });
+  } else {
+    throw new DataError(
+      ".tree file import is not supported in browser. Use readFileAsText() with a File object.",
+      "ENVIRONMENT_NOT_SUPPORTED" /* ENVIRONMENT_NOT_SUPPORTED */,
+      { data: { environment: "browser", operation: "importTree" } }
+    );
+  }
+}
+async function exportTxt(data, filePath, options) {
+  const { separator = "\n", stringify, indent = 2 } = options || {};
+  let textContent;
+  if (stringify) {
+    textContent = stringify(data);
+  } else if (typeof data === "string") {
+    textContent = data;
+  } else if (Array.isArray(data)) {
+    textContent = data.map((item) => typeof item === "string" ? item : JSON.stringify(item, null, indent)).join(separator);
+  } else if (typeof data === "object" && data !== null) {
+    textContent = JSON.stringify(data, null, indent);
+  } else {
+    textContent = String(data);
+  }
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, textContent, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([textContent], { type: "text/plain;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "file.txt";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+function sanitizeTextContent(content) {
+  return content.replace(/\r\n|\r/g, "\n").replace(/[\x00-\x08\x0E-\x1F\x7F]/g, "").replace(/\n{4,}/g, "\n\n\n").replace(/[ \t]+$/gm, "");
+}
+async function importTxt(filePath, options = {}) {
+  const {
+    maxFileSize = 10 * 1024 * 1024,
+    // 10MB default
+    maxLength = 1e6,
+    // 1M characters default
+    validateSecurity = true,
+    sanitize = true
+  } = options;
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const { isValidFilePath: isValidFilePath2, isValidFileSize: isValidFileSize2, isValidTextContent: isValidTextContent2 } = await Promise.resolve().then(() => (init_validators(), validators_exports));
+    if (!isValidFilePath2(filePath)) {
+      throw new Error("Invalid or unsafe file path");
+    }
+    const resolvedPath = path.resolve(filePath);
+    try {
+      const stats = await fs.stat(resolvedPath);
+      if (!isValidFileSize2(stats.size, maxFileSize)) {
+        throw new Error(`File too large: ${stats.size} bytes (max: ${maxFileSize})`);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`File not found: ${filePath}`);
+      }
+      throw error;
+    }
+    const content = await fs.readFile(resolvedPath, { encoding: "utf-8" });
+    if (validateSecurity && !isValidTextContent2(content, { maxLength })) {
+      throw new Error("File contains potentially dangerous content or exceeds security limits");
+    }
+    return sanitize ? sanitizeTextContent(content) : content;
+  } else {
+    throw new Error(
+      ".txt file import is not supported in browser. Use readFileAsText() with a File object."
+    );
+  }
+}
+async function exportData(data, filePath, options) {
+  const format2 = detectFormatFromFilename(filePath);
+  if (format2 === "csv") {
+    validateExportData(data);
+  }
+  switch (format2) {
+    case "csv": {
+      const { exportCSV: exportCSV2 } = await Promise.resolve().then(() => (init_csv(), csv_exports));
+      return exportCSV2(data, filePath, options);
+    }
+    case "json": {
+      const { exportJSON: exportJSON2 } = await Promise.resolve().then(() => (init_json(), json_exports));
+      return exportJSON2(data, filePath, options);
+    }
+    case "tree": {
+      return exportTree(data, filePath, options);
+    }
+    case "txt": {
+      return exportTxt(data, filePath, options);
+    }
+    default:
+      throw new Error(`Unsupported format: ${format2}`);
+  }
+}
+async function importData(filePath, options) {
+  const format2 = detectFormatFromFilename(filePath);
+  switch (format2) {
+    case "csv": {
+      const { importCSV: importCSV2 } = await Promise.resolve().then(() => (init_csv(), csv_exports));
+      return importCSV2(filePath, options);
+    }
+    case "json": {
+      const { importJSON: importJSON2 } = await Promise.resolve().then(() => (init_json(), json_exports));
+      return importJSON2(filePath, options);
+    }
+    case "tree": {
+      return importTree(filePath, options);
+    }
+    case "txt": {
+      return importTxt(filePath, options);
+    }
+    default:
+      throw new Error(`Unsupported format: ${format2}`);
+  }
+}
+
+// src/node/index.ts
+init_environment();
+init_tree();
+
+// src/node/validation-crypto.ts
+var validation_crypto_exports = {};
+__export(validation_crypto_exports, {
+  escapeShellCommand: () => escapeShellCommand,
+  generateNonce: () => generateNonce,
+  generateSecureToken: () => generateSecureToken,
+  hashString: () => hashString,
+  isSecureUrl: () => isSecureUrl,
+  isValidBase64: () => isValidBase64,
+  isValidJWTFormat: () => isValidJWTFormat,
+  removeDangerousChars: () => removeDangerousChars,
+  sanitizeHtml: () => sanitizeHtml,
+  validatePassword: () => validatePassword
+});
+var import_crypto = require("crypto");
+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 = "") => {
+  return (0, import_crypto.createHash)("sha256").update(input + salt).digest("hex");
+};
+var generateSecureToken = (length = 32) => {
+  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 = "";
+  const bytes = (0, import_crypto.randomBytes)(length);
+  for (let i = 0; i < length; i++) {
+    result += chars[bytes[i] % chars.length];
+  }
+  return result;
+};
+
+// src/node/index.ts
+init_environment();
+init_tree();
+var validationFunctions = {
+  ...validation_core_exports,
+  ...validation_crypto_exports
+};
+var g = {
+  // Full validation functions (core + crypto)
+  ...validationFunctions,
+  // String functions
+  ...strings_exports,
+  // Object/Array functions
+  ...objects_exports,
+  // Date functions
+  ...dates_exports,
+  // Math functions
+  ...math_exports,
+  // Async functions
+  ...async_exports,
+  // Data functions
+  ...data_exports,
+  // Number utilities
+  ...number_exports,
+  // Tree utilities
+  ...tree_exports,
+  // Environment utilities
+  ...environment_exports
+};
+var node_default = g;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addDays,
+  addMonths,
+  addNowDays,
+  addNowMonths,
+  addNowSeconds,
+  addNowYears,
+  addSeconds,
+  addYears,
+  areDatesEqualWithTolerance,
+  async,
+  calculateAggregations,
+  calculateAnnuityPayment,
+  calculateCorrelation,
+  calculateDifferences,
+  calculateEuclideanDistance,
+  calculateFutureValue,
+  calculateHistogram,
+  calculateIQR,
+  calculateIRR,
+  calculateManhattanDistance,
+  calculateMedian,
+  calculateMode,
+  calculateNPV,
+  calculatePercentile,
+  calculatePresentValue,
+  calculateQuartiles,
+  calculateStandardDeviation,
+  calculateTrendSlope,
+  calculateVariance,
+  capitalizeEachWord,
+  capitalizeFirst,
+  cleanJsonChars,
+  comparator,
+  contains,
+  countOccurrences,
+  data,
+  dates,
+  dayOfWeek,
+  deepEqual,
+  deleteArrayElementsBy,
+  detectFileExtension,
+  detectFormatFromFilename,
+  detectHostname,
+  detectOutliers,
+  detectProtocol,
+  detectUniversalFormat,
+  diffBusinessDays,
+  diffDays,
+  diffMilliSeconds,
+  diffMonths,
+  diffYears,
+  endsWith,
+  ensureEndsWith,
+  ensureStartsWith,
+  envKeyToPath,
+  environment,
+  escapeHtmlChars,
+  escapeShellCommand,
+  excelToDate,
+  exportData,
+  exportTree,
+  exportTxt,
+  format,
+  formatForMysql,
+  formatNow,
+  formatToReadableString,
+  fromNow,
+  generateAlphaNumericString,
+  generateAlphaString,
+  generateComplexString,
+  generateCrcHash,
+  generateEmail,
+  generateHexColor,
+  generateNonce,
+  generatePassword,
+  generateRandomInteger,
+  generateSecureToken,
+  generateSpanishCIF,
+  generateSpanishIBAN,
+  generateSpanishNIE,
+  generateSpanishNIF,
+  generateSpanishPostalCode,
+  generateUsername,
+  generateUsernameFromEmail,
+  getDeepValue,
+  getEnvironmentInfo,
+  getFirstDayOfYear,
+  getFirstWorkdayAfterMonths,
+  getFirstWorkdayOfMonth,
+  getLastDayOfYear,
+  getLastWorkdayOfMonth,
+  getShallowProperties,
+  handleOperation,
+  hasSameType,
+  hashString,
+  importData,
+  importTree,
+  importTxt,
+  isBrowser,
+  isBrowserEnvironment,
+  isDateTime,
+  isDevelopment,
+  isEmail,
+  isEmpty,
+  isEqualsDateTimeByDay,
+  isExpired,
+  isLocalhost,
+  isNew,
+  isNode,
+  isNodeEnvironment,
+  isNonProduction,
+  isNumericValue,
+  isPrivateIP,
+  isProduction,
+  isSecureUrl,
+  isTest,
+  isValidBase64,
+  isValidCIF,
+  isValidEmail,
+  isValidJSON,
+  isValidJWTFormat,
+  isValidNIE,
+  isValidNIF,
+  isValidSpanishIBAN,
+  isValidSpanishPhone,
+  isValidSpanishPostalCode,
+  isValidURL,
+  isWeekday,
+  longString,
+  matchPathPattern,
+  math,
+  normalizeToRange,
+  now,
+  number,
+  objects,
+  padEnd,
+  padStart,
+  parseEnvValue,
+  pathToEnvKey,
+  readFileAsText,
+  removeAccents,
+  removeDangerousChars,
+  renderTreeAsText,
+  repeatString,
+  replaceAllOccurrences,
+  reverseString,
+  roundToDecimals,
+  runBatch,
+  sanitizeHtml,
+  sanitizeString,
+  scaleToRange,
+  setDeepValue,
+  simpleKMeans,
+  sleep,
+  startsWith,
+  strings,
+  stripFromEnd,
+  stripFromStart,
+  toCamelCase,
+  toDate,
+  toDateFromString,
+  toISO,
+  toKebabCase,
+  toLowerCase,
+  toPascalCase,
+  toSnakeCase,
+  toUpperCase,
+  toUrlSlug,
+  tree,
+  trim,
+  trimEnd,
+  trimStart,
+  truncateString,
+  unescapeHtmlChars,
+  unescapeUnicode,
+  updateArrayElementById,
+  updateArrayElementsBy,
+  validateCSVData,
+  validateExportData,
+  validateNIF,
+  validatePassword,
+  validation,
+  wait,
+  weekOfYear
+});
+//# sourceMappingURL=index.js.map