@gzl10/ts-helpers 4.2.1

package/dist/browser/chunk-D4FZFIVA.js

@@ -0,0 +1,240 @@
+import {
+  __export,
+  __require
+} from "./chunk-NSBPE2FW.js";
+
+// src/browser/validation-crypto.ts
+var validation_crypto_exports = {};
+__export(validation_crypto_exports, {
+  escapeShellCommand: () => escapeShellCommand,
+  generateNonce: () => generateNonce,
+  generateSecureToken: () => generateSecureToken,
+  hashString: () => hashString,
+  hashStringSync: () => hashStringSync,
+  isSecureUrl: () => isSecureUrl,
+  isValidBase64: () => isValidBase64,
+  isValidJWTFormat: () => isValidJWTFormat,
+  removeDangerousChars: () => removeDangerousChars,
+  sanitizeHtml: () => sanitizeHtml,
+  validatePassword: () => validatePassword
+});
+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 = async (input, salt = "") => {
+  const combined = input + salt;
+  if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.digest) {
+    try {
+      const msgBuffer = new TextEncoder().encode(combined);
+      const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    } catch (error) {
+      console.warn("Web Crypto API failed, falling back to simple hash:", error);
+    }
+  }
+  let hash = 0;
+  for (let i = 0; i < combined.length; i++) {
+    const char = combined.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16);
+};
+var hashStringSync = (input, salt = "") => {
+  let hash = 0;
+  const combined = input + salt;
+  for (let i = 0; i < combined.length; i++) {
+    const char = combined.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16);
+};
+var generateSecureToken = (length = 32) => {
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    try {
+      const array = new Uint8Array(length);
+      crypto.getRandomValues(array);
+      return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    } catch (error) {
+      console.warn("crypto.getRandomValues failed, falling back to Math.random:", error);
+    }
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    try {
+      const crypto2 = __require("crypto");
+      return crypto2.randomBytes(length).toString("hex");
+    } catch (error) {
+      console.warn("Node.js crypto failed, falling back to Math.random:", error);
+    }
+  }
+  console.warn("Using Math.random fallback - not cryptographically secure");
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length * 2; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+};
+var isValidBase64 = (input) => {
+  if (!input || typeof input !== "string") return false;
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(input)) return false;
+  try {
+    const decoded = atob(input);
+    const reencoded = btoa(decoded);
+    return reencoded === input;
+  } catch {
+    return false;
+  }
+};
+var escapeShellCommand = (input) => {
+  if (!input) return "";
+  return input.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/;/g, "\\;").replace(/&/g, "\\&").replace(/\|/g, "\\|").replace(/`/g, "\\`").replace(/\$/g, "\\$").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/</g, "\\\\<").replace(/>/g, "\\\\>");
+};
+var isSecureUrl = (url) => {
+  if (!url || typeof url !== "string") return false;
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "https:" || parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1");
+  } catch {
+    return false;
+  }
+};
+var removeDangerousChars = (input, replacement = "") => {
+  if (!input) return "";
+  return input.replace(/[<>]/g, replacement).replace(/['"]/g, replacement).replace(/[&]/g, replacement).replace(/[\\x00-\\x1f\\x7f]/g, replacement);
+};
+var generateNonce = (length = 32) => {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    try {
+      const array = new Uint8Array(length);
+      crypto.getRandomValues(array);
+      for (let i = 0; i < length; i++) {
+        result += chars[array[i] % chars.length];
+      }
+      return result;
+    } catch (error) {
+      console.warn("crypto.getRandomValues failed for nonce, falling back to Math.random:", error);
+    }
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    try {
+      const crypto2 = __require("crypto");
+      const bytes = crypto2.randomBytes(length);
+      for (let i = 0; i < length; i++) {
+        result += chars[bytes[i] % chars.length];
+      }
+      return result;
+    } catch (error) {
+      console.warn("Node.js crypto failed for nonce, falling back to Math.random:", error);
+    }
+  }
+  console.warn("Using Math.random fallback for nonce - not cryptographically secure");
+  for (let i = 0; i < length; i++) {
+    result += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return result;
+};
+
+export {
+  validatePassword,
+  sanitizeHtml,
+  isValidJWTFormat,
+  hashString,
+  hashStringSync,
+  generateSecureToken,
+  isValidBase64,
+  escapeShellCommand,
+  isSecureUrl,
+  removeDangerousChars,
+  generateNonce,
+  validation_crypto_exports
+};
+//# sourceMappingURL=chunk-D4FZFIVA.js.map

package/dist/browser/chunk-D4FZFIVA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/browser/validation-crypto.ts"],"sourcesContent":["/**\n * Browser-specific validation utilities with Web Crypto API support\n * Safe for browser environments - uses crypto.getRandomValues() and SubtleCrypto\n */\n\n/* eslint-disable no-console, complexity */\n\n// =============================================================================\n// PASSWORD VALIDATION (Browser-safe)\n// =============================================================================\n\nexport interface PasswordCriteria {\n  minLength?: number\n  requireUppercase?: boolean\n  requireLowercase?: boolean\n  requireNumbers?: boolean\n  requireSpecialChars?: boolean\n  maxLength?: number\n  forbiddenPatterns?: string[]\n}\n\nexport interface PasswordValidationResult {\n  isValid: boolean\n  errors: string[]\n  strength: 'weak' | 'fair' | 'good' | 'strong'\n  score: number // 0-100\n}\n\nexport const validatePassword = (\n  password: string,\n  criteria: PasswordCriteria = {}\n): PasswordValidationResult => {\n  const {\n    minLength = 8,\n    requireUppercase = true,\n    requireLowercase = true,\n    requireNumbers = true,\n    requireSpecialChars = true,\n    maxLength = 128,\n    forbiddenPatterns = [],\n  } = criteria\n\n  const errors: string[] = []\n  let score = 0\n\n  if (password.length < minLength) {\n    errors.push(`La contraseña debe tener al menos ${minLength} caracteres`)\n  } else {\n    score += 20\n  }\n\n  if (password.length > maxLength) {\n    errors.push(`La contraseña no puede tener más de ${maxLength} caracteres`)\n  }\n\n  if (requireUppercase && !/[A-Z]/.test(password)) {\n    errors.push('La contraseña debe contener al menos una letra mayúscula')\n  } else if (/[A-Z]/.test(password)) {\n    score += 15\n  }\n\n  if (requireLowercase && !/[a-z]/.test(password)) {\n    errors.push('La contraseña debe contener al menos una letra minúscula')\n  } else if (/[a-z]/.test(password)) {\n    score += 15\n  }\n\n  if (requireNumbers && !/\\d/.test(password)) {\n    errors.push('La contraseña debe contener al menos un número')\n  } else if (/\\d/.test(password)) {\n    score += 15\n  }\n\n  if (requireSpecialChars && !/[!@#$%^&*()_+\\-=[\\]{};':\"\\\\|,.<>/?]/.test(password)) {\n    errors.push('La contraseña debe contener al menos un caracter especial')\n  } else if (/[!@#$%^&*()_+\\-=[\\]{};':\"\\\\|,.<>/?]/.test(password)) {\n    score += 15\n  }\n\n  for (const pattern of forbiddenPatterns) {\n    if (password.toLowerCase().includes(pattern.toLowerCase())) {\n      errors.push(`La contraseña no puede contener: ${pattern}`)\n    }\n  }\n\n  if (password.length >= 12) score += 10\n  if (password.length >= 16) score += 10\n\n  if (/(.)\\\\1{2,}/.test(password)) score -= 10\n  if (/123|abc|qwe/i.test(password)) score -= 15\n\n  score = Math.max(0, Math.min(100, score))\n\n  let strength: 'weak' | 'fair' | 'good' | 'strong'\n  if (score < 30) strength = 'weak'\n  else if (score < 60) strength = 'fair'\n  else if (score < 80) strength = 'good'\n  else strength = 'strong'\n\n  return {\n    isValid: errors.length === 0,\n    errors,\n    strength,\n    score,\n  }\n}\n\n// =============================================================================\n// SECURITY FUNCTIONS (Browser-safe)\n// =============================================================================\n\nexport const sanitizeHtml = (html: string): string => {\n  if (!html) return ''\n\n  let sanitized = html\n    .replace(/<script\\b[^<]*(?:(?!<\\/script>)<[^<]*)*<\\/script>/gi, '')\n    .replace(/<style\\b[^<]*(?:(?!<\\/style>)<[^<]*)*<\\/style>/gi, '')\n\n  sanitized = sanitized.replace(/ on\\w+=\"[^\"]*\"/gi, '')\n  sanitized = sanitized.replace(/ on\\w+='[^']*'/gi, '')\n  sanitized = sanitized.replace(/javascript:/gi, '')\n  sanitized = sanitized.replace(/<iframe\\b[^<]*(?:(?!<\\/iframe>)<[^<]*)*<\\/iframe>/gi, '')\n  sanitized = sanitized.replace(/<object\\b[^<]*(?:(?!<\\/object>)<[^<]*)*<\\/object>/gi, '')\n  sanitized = sanitized.replace(/<embed\\b[^>]*>/gi, '')\n\n  return sanitized.trim()\n}\n\nexport const isValidJWTFormat = (token: string): boolean => {\n  if (!token || typeof token !== 'string') return false\n\n  const parts = token.split('.')\n  if (parts.length !== 3) return false\n\n  try {\n    for (const part of parts) {\n      if (!part || !/^[A-Za-z0-9_-]+$/.test(part)) return false\n      atob(part.replace(/-/g, '+').replace(/_/g, '/'))\n    }\n    return true\n  } catch {\n    return false\n  }\n}\n\n/**\n * Browser-safe hash function with environment detection\n * Attempts Web Crypto API first, falls back to simple hash\n */\nexport const hashString = async (input: string, salt = ''): Promise<string> => {\n  const combined = input + salt\n\n  // Try Web Crypto API (modern browsers)\n  if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.digest) {\n    try {\n      const msgBuffer = new TextEncoder().encode(combined)\n      const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer)\n      const hashArray = Array.from(new Uint8Array(hashBuffer))\n      return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')\n    } catch (error) {\n      console.warn('Web Crypto API failed, falling back to simple hash:', error)\n    }\n  }\n\n  // Fallback: Simple hash for compatibility\n  let hash = 0\n  for (let i = 0; i < combined.length; i++) {\n    const char = combined.charCodeAt(i)\n    hash = (hash << 5) - hash + char\n    hash = hash & hash // Convert to 32-bit integer\n  }\n  return Math.abs(hash).toString(16)\n}\n\n/**\n * Synchronous version of hashString for backward compatibility\n */\nexport const hashStringSync = (input: string, salt = ''): string => {\n  // Simple hash for browser compatibility\n  let hash = 0\n  const combined = input + salt\n  for (let i = 0; i < combined.length; i++) {\n    const char = combined.charCodeAt(i)\n    hash = (hash << 5) - hash + char\n    hash = hash & hash // Convert to 32-bit integer\n  }\n  return Math.abs(hash).toString(16)\n}\n\n/**\n * Browser-safe secure token generation with comprehensive environment checks\n * Uses Web Crypto API when available, falls back to Node.js crypto, then Math.random\n * @param length - Length of the token in characters (default: 32)\n * @returns A secure hexadecimal token string\n * @example\n * ```ts\n * const token = generateSecureToken(16)\n * console.log(token) // \"a1b2c3d4e5f67890\"\n *\n * const shortToken = generateSecureToken(8)\n * console.log(shortToken) // \"a1b2c3d4\"\n * ```\n */\nexport const generateSecureToken = (length = 32): string => {\n  // Check for Web Crypto API (modern browsers)\n  if (typeof crypto !== 'undefined' && crypto.getRandomValues) {\n    try {\n      const array = new Uint8Array(length)\n      crypto.getRandomValues(array)\n      return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('')\n    } catch (error) {\n      console.warn('crypto.getRandomValues failed, falling back to Math.random:', error)\n    }\n  }\n\n  // Check for Node.js crypto (if somehow running in Node context)\n  if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n    try {\n      // Dynamic import to avoid bundling issues\n      const crypto = require('crypto')\n      return crypto.randomBytes(length).toString('hex')\n    } catch (error) {\n      console.warn('Node.js crypto failed, falling back to Math.random:', error)\n    }\n  }\n\n  // Final fallback: Math.random (less secure but universal)\n  console.warn('Using Math.random fallback - not cryptographically secure')\n  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'\n  let result = ''\n  for (let i = 0; i < length * 2; i++) {\n    result += chars.charAt(Math.floor(Math.random() * chars.length))\n  }\n  return result\n}\n\nexport const isValidBase64 = (input: string): boolean => {\n  if (!input || typeof input !== 'string') return false\n\n  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(input)) return false\n\n  try {\n    const decoded = atob(input)\n    const reencoded = btoa(decoded)\n    return reencoded === input\n  } catch {\n    return false\n  }\n}\n\nexport const escapeShellCommand = (input: string): string => {\n  if (!input) return ''\n\n  return input\n    .replace(/\\\\/g, '\\\\\\\\')\n    .replace(/'/g, \"\\\\'\")\n    .replace(/\"/g, '\\\\\"')\n    .replace(/;/g, '\\\\;')\n    .replace(/&/g, '\\\\&')\n    .replace(/\\|/g, '\\\\|')\n    .replace(/`/g, '\\\\`')\n    .replace(/\\$/g, '\\\\$')\n    .replace(/\\(/g, '\\\\(')\n    .replace(/\\)/g, '\\\\)')\n    .replace(/</g, '\\\\\\\\<')\n    .replace(/>/g, '\\\\\\\\>')\n}\n\nexport const isSecureUrl = (url: string): boolean => {\n  if (!url || typeof url !== 'string') return false\n\n  try {\n    const parsed = new URL(url)\n    return (\n      parsed.protocol === 'https:' ||\n      (parsed.protocol === 'http:' &&\n        (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1'))\n    )\n  } catch {\n    return false\n  }\n}\n\nexport const removeDangerousChars = (input: string, replacement = ''): string => {\n  if (!input) return ''\n\n  return input\n    .replace(/[<>]/g, replacement)\n    .replace(/['\"]/g, replacement)\n    .replace(/[&]/g, replacement)\n    .replace(/[\\\\x00-\\\\x1f\\\\x7f]/g, replacement)\n}\n\n/**\n * Browser-safe nonce generation with comprehensive environment detection\n */\nexport const generateNonce = (length = 32): string => {\n  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'\n  let result = ''\n\n  // Try Web Crypto API first (modern browsers)\n  if (typeof crypto !== 'undefined' && crypto.getRandomValues) {\n    try {\n      const array = new Uint8Array(length)\n      crypto.getRandomValues(array)\n      for (let i = 0; i < length; i++) {\n        result += chars[array[i] % chars.length]\n      }\n      return result\n    } catch (error) {\n      console.warn('crypto.getRandomValues failed for nonce, falling back to Math.random:', error)\n    }\n  }\n\n  // Check for Node.js environment (edge case)\n  if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n    try {\n      const crypto = require('crypto')\n      const bytes = crypto.randomBytes(length)\n      for (let i = 0; i < length; i++) {\n        result += chars[bytes[i] % chars.length]\n      }\n      return result\n    } catch (error) {\n      console.warn('Node.js crypto failed for nonce, falling back to Math.random:', error)\n    }\n  }\n\n  // Final fallback: Math.random (less secure but universal)\n  console.warn('Using Math.random fallback for nonce - not cryptographically secure')\n  for (let i = 0; i < length; i++) {\n    result += chars[Math.floor(Math.random() * chars.length)]\n  }\n  return result\n}\n"],"mappings":"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","names":["crypto"]}

package/dist/browser/chunk-IL7NG7IC.js

@@ -0,0 +1,72 @@
+import {
+  isBrowserEnvironment,
+  isNodeEnvironment
+} from "./chunk-ZYTSVMTI.js";
+import {
+  __export,
+  __require
+} from "./chunk-NSBPE2FW.js";
+
+// src/universal/environment-detection.ts
+var environment_detection_exports = {};
+__export(environment_detection_exports, {
+  getCryptoCapabilities: () => getCryptoCapabilities,
+  getEnvironmentType: () => getEnvironmentType,
+  isBrowserEnv: () => isBrowserEnv,
+  isNodeCryptoAvailable: () => isNodeCryptoAvailable,
+  isNodeEnv: () => isNodeEnv,
+  isWebCryptoAvailable: () => isWebCryptoAvailable,
+  isWorkerEnvironment: () => isWorkerEnvironment
+});
+var isBrowserEnv = isBrowserEnvironment;
+var isNodeEnv = isNodeEnvironment;
+var isWorkerEnvironment = () => {
+  try {
+    return typeof importScripts === "function" && typeof self !== "undefined" && // Check for Worker global scope without importing types
+    "importScripts" in self;
+  } catch {
+    return false;
+  }
+};
+var isWebCryptoAvailable = () => {
+  try {
+    return typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function" && typeof crypto.subtle === "object";
+  } catch {
+    return false;
+  }
+};
+var isNodeCryptoAvailable = () => {
+  try {
+    if (!isNodeEnv()) return false;
+    const crypto2 = __require("crypto");
+    return typeof crypto2.createHash === "function" && typeof crypto2.randomBytes === "function";
+  } catch {
+    return false;
+  }
+};
+var getEnvironmentType = () => {
+  if (isNodeEnv()) return "node";
+  if (isWorkerEnvironment()) return "worker";
+  if (isBrowserEnv()) return "browser";
+  return "unknown";
+};
+var getCryptoCapabilities = () => {
+  return {
+    webCrypto: isWebCryptoAvailable(),
+    nodeCrypto: isNodeCryptoAvailable(),
+    fallbackOnly: !isWebCryptoAvailable() && !isNodeCryptoAvailable(),
+    environment: getEnvironmentType()
+  };
+};
+
+export {
+  isBrowserEnv,
+  isNodeEnv,
+  isWorkerEnvironment,
+  isWebCryptoAvailable,
+  isNodeCryptoAvailable,
+  getEnvironmentType,
+  getCryptoCapabilities,
+  environment_detection_exports
+};
+//# sourceMappingURL=chunk-IL7NG7IC.js.map

package/dist/browser/chunk-IL7NG7IC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/universal/environment-detection.ts"],"sourcesContent":["/**\n * Universal crypto capabilities detection utilities\n * Safe for all environments with comprehensive fallbacks\n */\n\nimport { isBrowserEnvironment, isNodeEnvironment } from '../environment'\n\n// Global type declarations for Worker environment (avoid importing lib.webworker)\ndeclare const importScripts: any\ndeclare const self: any\n\n/**\n * Enhanced browser environment detection with additional checks\n * @returns true if running in a browser environment\n * @example\n * ```ts\n * if (isBrowserEnv()) {\n *   console.log('Running in browser')\n * }\n * ```\n */\nexport const isBrowserEnv = isBrowserEnvironment\n\n/**\n * Enhanced Node.js environment detection with additional checks\n * @returns true if running in Node.js environment\n * @example\n * ```ts\n * if (isNodeEnv()) {\n *   console.log('Running in Node.js')\n * }\n * ```\n */\nexport const isNodeEnv = isNodeEnvironment\n\n/**\n * Detects if running in Worker environment (Web Workers, Service Workers)\n * @returns true if running in a Worker context\n * @example\n * ```ts\n * if (isWorkerEnvironment()) {\n *   console.log('Running in Web Worker')\n * }\n * ```\n */\nexport const isWorkerEnvironment = (): boolean => {\n  try {\n    return (\n      typeof importScripts === 'function' &&\n      typeof self !== 'undefined' &&\n      // Check for Worker global scope without importing types\n      'importScripts' in self\n    )\n  } catch {\n    return false\n  }\n}\n\n/**\n * Detects if Web Crypto API is available in the current environment\n * @returns true if crypto.getRandomValues and crypto.subtle are available\n * @example\n * ```ts\n * if (isWebCryptoAvailable()) {\n *   const array = new Uint8Array(16)\n *   crypto.getRandomValues(array)\n * }\n * ```\n */\nexport const isWebCryptoAvailable = (): boolean => {\n  try {\n    return (\n      typeof crypto !== 'undefined' &&\n      typeof crypto.getRandomValues === 'function' &&\n      typeof crypto.subtle === 'object'\n    )\n  } catch {\n    return false\n  }\n}\n\n/**\n * Detects if Node.js crypto module is available\n * @returns true if Node.js crypto module with hash and random functions is available\n * @example\n * ```ts\n * if (isNodeCryptoAvailable()) {\n *   const crypto = require('crypto')\n *   const hash = crypto.createHash('sha256')\n * }\n * ```\n */\nexport const isNodeCryptoAvailable = (): boolean => {\n  try {\n    if (!isNodeEnv()) return false\n    const crypto = require('crypto')\n    return typeof crypto.createHash === 'function' && typeof crypto.randomBytes === 'function'\n  } catch {\n    return false\n  }\n}\n\n/**\n * Gets the current environment type with automatic detection\n * @returns The detected environment type\n * @example\n * ```ts\n * const env = getEnvironmentType()\n * switch (env) {\n *   case 'node': console.log('Server-side'); break\n *   case 'browser': console.log('Client-side'); break\n *   case 'worker': console.log('Worker thread'); break\n *   case 'unknown': console.log('Unknown environment'); break\n * }\n * ```\n */\nexport const getEnvironmentType = (): 'node' | 'browser' | 'worker' | 'unknown' => {\n  if (isNodeEnv()) return 'node'\n  if (isWorkerEnvironment()) return 'worker'\n  if (isBrowserEnv()) return 'browser'\n  return 'unknown'\n}\n\n/**\n * Gets available crypto capabilities for the current environment\n * @returns Object containing crypto capability information\n * @example\n * ```ts\n * const caps = getCryptoCapabilities()\n * console.log(caps)\n * // {\n * //   webCrypto: true,\n * //   nodeCrypto: false,\n * //   fallbackOnly: false,\n * //   environment: 'browser'\n * // }\n * ```\n */\nexport const getCryptoCapabilities = () => {\n  return {\n    webCrypto: isWebCryptoAvailable(),\n    nodeCrypto: isNodeCryptoAvailable(),\n    fallbackOnly: !isWebCryptoAvailable() && !isNodeCryptoAvailable(),\n    environment: getEnvironmentType(),\n  }\n}\n"],"mappings":";;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,IAAM,eAAe;AAYrB,IAAM,YAAY;AAYlB,IAAM,sBAAsB,MAAe;AAChD,MAAI;AACF,WACE,OAAO,kBAAkB,cACzB,OAAO,SAAS;AAAA,IAEhB,mBAAmB;AAAA,EAEvB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAaO,IAAM,uBAAuB,MAAe;AACjD,MAAI;AACF,WACE,OAAO,WAAW,eAClB,OAAO,OAAO,oBAAoB,cAClC,OAAO,OAAO,WAAW;AAAA,EAE7B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAaO,IAAM,wBAAwB,MAAe;AAClD,MAAI;AACF,QAAI,CAAC,UAAU,EAAG,QAAO;AACzB,UAAMA,UAAS,UAAQ,QAAQ;AAC/B,WAAO,OAAOA,QAAO,eAAe,cAAc,OAAOA,QAAO,gBAAgB;AAAA,EAClF,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAgBO,IAAM,qBAAqB,MAAiD;AACjF,MAAI,UAAU,EAAG,QAAO;AACxB,MAAI,oBAAoB,EAAG,QAAO;AAClC,MAAI,aAAa,EAAG,QAAO;AAC3B,SAAO;AACT;AAiBO,IAAM,wBAAwB,MAAM;AACzC,SAAO;AAAA,IACL,WAAW,qBAAqB;AAAA,IAChC,YAAY,sBAAsB;AAAA,IAClC,cAAc,CAAC,qBAAqB,KAAK,CAAC,sBAAsB;AAAA,IAChE,aAAa,mBAAmB;AAAA,EAClC;AACF;","names":["crypto"]}

package/dist/browser/chunk-NSBPE2FW.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __require,
+  __export
+};
+//# sourceMappingURL=chunk-NSBPE2FW.js.map

package/dist/browser/chunk-NSBPE2FW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/browser/chunk-SLQVNPTH.js

@@ -0,0 +1,27 @@
+import {
+  __export
+} from "./chunk-NSBPE2FW.js";
+
+// 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;
+}
+
+export {
+  isNumericValue,
+  roundToDecimals,
+  number_exports
+};
+//# sourceMappingURL=chunk-SLQVNPTH.js.map

package/dist/browser/chunk-SLQVNPTH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/number.ts"],"sourcesContent":["/**\n * Number utilities\n */\n\n/**\n * Verifica si un valor es numéricamente válido o convertible a número.\n * Acepta números y cadenas que representan números válidos.\n * @param value - El valor a verificar.\n * @returns true si el valor es numéricamente válido, false en caso contrario.\n * @example\n * ```ts\n * isNumericValue(5) // true\n * isNumericValue(\"5\") // true\n * isNumericValue(\"12.34\") // true\n * isNumericValue(\"-42\") // true\n * isNumericValue(\"abc\") // false\n * isNumericValue(\"\") // false\n * isNumericValue(\" \") // false\n * isNumericValue(null) // false\n * isNumericValue(undefined) // false\n * isNumericValue(NaN) // false\n * isNumericValue(Infinity) // false\n * ```\n */\nexport function isNumericValue(value: any): boolean {\n  if (value === null || value === undefined) return false\n  if (typeof value === 'number') return !isNaN(value) && isFinite(value)\n  if (typeof value === 'string') return value.trim() !== '' && !isNaN(Number(value))\n  return false\n}\n\n/**\n * Rounds a number to a specified number of decimal places\n * @param num - The number to round\n * @param decimals - Number of decimal places (default: 2)\n * @returns The rounded number\n * @example\n * ```ts\n * roundToDecimals(3.14159, 2) // 3.14\n * roundToDecimals(-2.7182, 3) // -2.718\n * ```\n */\nexport function roundToDecimals(num: number, decimals: number = 2): number {\n  const factor = Math.pow(10, decimals)\n  // Use sign-aware rounding to handle negative numbers correctly\n  return num >= 0 ? Math.round(num * factor) / factor : -Math.round(Math.abs(num) * factor) / factor\n}\n"],"mappings":";;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBO,SAAS,eAAe,OAAqB;AAClD,MAAI,UAAU,QAAQ,UAAU,OAAW,QAAO;AAClD,MAAI,OAAO,UAAU,SAAU,QAAO,CAAC,MAAM,KAAK,KAAK,SAAS,KAAK;AACrE,MAAI,OAAO,UAAU,SAAU,QAAO,MAAM,KAAK,MAAM,MAAM,CAAC,MAAM,OAAO,KAAK,CAAC;AACjF,SAAO;AACT;AAaO,SAAS,gBAAgB,KAAa,WAAmB,GAAW;AACzE,QAAM,SAAS,KAAK,IAAI,IAAI,QAAQ;AAEpC,SAAO,OAAO,IAAI,KAAK,MAAM,MAAM,MAAM,IAAI,SAAS,CAAC,KAAK,MAAM,KAAK,IAAI,GAAG,IAAI,MAAM,IAAI;AAC9F;","names":[]}

package/dist/browser/chunk-WG7ILCUB.js

@@ -0,0 +1,195 @@
+import {
+  areDatesEqualWithTolerance,
+  isDateTime,
+  toDate
+} from "./chunk-C3D7YZVE.js";
+import {
+  __export
+} from "./chunk-NSBPE2FW.js";
+
+// 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
+});
+import crc32 from "crc/crc32";
+import * as lodash from "lodash";
+import fastEqual from "fast-deep-equal";
+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) => fastEqual(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 crc32("-").toString(16);
+  if (isString(str)) return crc32(str).toString(16);
+  if (isBuffer(str)) return crc32(str).toString(16);
+  if (isArrayBuffer(str)) return crc32(str).toString(16);
+  if (isBoolean(str)) return crc32(str ? "true" : "false").toString(16);
+  if (isNumber(str)) return crc32(str.toString()).toString(16);
+  if (isArray(str) || isObject(str)) return generateCrcHash(JSON.stringify(str));
+  return crc32(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;
+}
+
+export {
+  comparator,
+  deepEqual,
+  formatToReadableString,
+  getShallowProperties,
+  calculateDifferences,
+  generateCrcHash,
+  hasSameType,
+  updateArrayElementsBy,
+  updateArrayElementById,
+  deleteArrayElementsBy,
+  setDeepValue,
+  getDeepValue,
+  objects_exports
+};
+//# sourceMappingURL=chunk-WG7ILCUB.js.map