@gzl10/ts-helpers 4.2.1

package/dist/node/json.js

@@ -0,0 +1,107 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/json.ts
+var json_exports = {};
+__export(json_exports, {
+  exportJSON: () => exportJSON,
+  importJSON: () => importJSON
+});
+module.exports = __toCommonJS(json_exports);
+
+// src/environment.ts
+function isNodeEnvironment() {
+  return typeof window === "undefined" && typeof process !== "undefined" && !!process.versions?.node;
+}
+var isNode = isNodeEnvironment;
+
+// src/json.ts
+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."
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportJSON,
+  importJSON
+});
+//# sourceMappingURL=json.js.map

package/dist/node/json.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/json.ts","../../src/environment.ts"],"sourcesContent":["/**\n * JSON Import/Export utilities\n *\n * Provides reliable JSON file operations for both Node.js and Browser environments.\n * Features:\n * - UTF-8 encoding for international character support\n * - Pretty-printing with configurable indentation\n * - Dual-mode: filesystem (Node.js) vs download trigger (Browser)\n * - Native JSON.stringify/parse for maximum compatibility\n *\n * @module json\n */\n\nimport { isNode } from './environment'\n\n/**\n * Exports data as JSON file with UTF-8 encoding\n *\n * Works in both Node.js (writes to filesystem) and Browser (triggers download).\n * Uses native JSON.stringify for serialization with optional pretty-printing.\n *\n * Features:\n * - UTF-8 encoding for international characters\n * - Configurable indentation (default: 2 spaces)\n * - Automatic filename extraction in browser\n * - Pretty-printed by default for readability\n *\n * Environment behavior:\n * - **Node.js**: Writes file to filesystem at specified path\n * - **Browser**: Triggers automatic download with filename extracted from path\n *\n * ⚠️ WARNING: Cannot serialize:\n * - Functions (removed silently)\n * - Symbols (removed silently)\n * - Circular references (throws TypeError)\n * - undefined values (removed from objects, converted to null in arrays)\n * - BigInt values (throws TypeError unless custom replacer provided)\n *\n * @param data - Any serializable JavaScript value (object, array, primitive)\n * @param filePath - File path (Node.js) or download filename (Browser)\n * @param options - Export options (optional)\n * @param options.indent - Number of spaces for indentation (default: 2, use 0 for compact)\n * @returns Promise that resolves when export completes\n *\n * @example\n * ```typescript\n * // Basic export - Object\n * const config = {\n *   database: { host: 'localhost', port: 5432 },\n *   features: { auth: true, payments: false }\n * }\n *\n * // Node.js - Write to file\n * await exportJSON(config, './config/app.json')\n * // Creates: ./config/app.json with 2-space indentation\n *\n * // Browser - Trigger download\n * await exportJSON(config, 'app-config.json')\n * // Downloads: app-config.json to browser's download folder\n *\n * // Compact output (no pretty-printing)\n * await exportJSON(config, 'config.json', { indent: 0 })\n * // Single-line JSON: {\"database\":{\"host\":\"localhost\",\"port\":5432}}\n * ```\n *\n * @example\n * ```typescript\n * // Array export\n * const users = [\n *   { id: 1, name: 'Alice', email: 'alice@example.com' },\n *   { id: 2, name: 'Bob', email: 'bob@example.com' }\n * ]\n * await exportJSON(users, 'users.json')\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Configuration backup system\n * async function backupConfiguration(config: AppConfig) {\n *   const timestamp = new Date().toISOString().split('T')[0]\n *   const filename = `config-backup-${timestamp}.json`\n *\n *   try {\n *     await exportJSON(config, `./backups/${filename}`, { indent: 2 })\n *     console.log(`✅ Configuration backed up to ${filename}`)\n *   } catch (error) {\n *     console.error('❌ Backup failed:', error)\n *     throw error\n *   }\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Export API response for debugging\n * async function debugApiResponse(endpoint: string, data: any) {\n *   const filename = `api-${endpoint.replace(/\\//g, '-')}.json`\n *   await exportJSON({\n *     endpoint,\n *     timestamp: new Date().toISOString(),\n *     data\n *   }, filename)\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Handle circular references\n * const obj = { name: 'test' }\n * obj.self = obj  // Circular reference\n *\n * try {\n *   await exportJSON(obj, 'circular.json')\n * } catch (error) {\n *   console.error('Cannot serialize circular structure')\n *   // Use custom replacer to handle circular refs\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Different indentation levels\n * await exportJSON(data, 'compact.json', { indent: 0 })     // Single line\n * await exportJSON(data, 'readable.json', { indent: 2 })    // 2 spaces (default)\n * await exportJSON(data, 'spacious.json', { indent: 4 })    // 4 spaces\n * ```\n *\n * @throws {TypeError} If data contains circular references or BigInt values\n * @throws {Error} If file write fails in Node.js (permissions, disk space, etc.)\n * @see {@link importJSON} for importing JSON files\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify JSON.stringify Documentation}\n */\nexport async function exportJSON(\n  data: any,\n  filePath: string,\n  options?: { indent?: number }\n): Promise<void> {\n  // ✅ Input validation\n  if (data === null || data === undefined) {\n    throw new TypeError('Data cannot be null or undefined')\n  }\n\n  if (!filePath || typeof filePath !== 'string' || filePath.trim() === '') {\n    throw new TypeError('File path must be a non-empty string')\n  }\n\n  const { indent = 2 } = options || {}\n\n  // ✅ Detect circular references before stringify\n  let jsonText: string\n  try {\n    jsonText = JSON.stringify(data, null, indent)\n  } catch (error) {\n    if (error instanceof TypeError && error.message.includes('circular')) {\n      throw new TypeError('Cannot serialize data with circular references')\n    }\n    throw error\n  }\n\n  if (isNode()) {\n    const fs = await import('fs/promises')\n    await fs.writeFile(filePath, jsonText, { encoding: 'utf-8' })\n  } else {\n    const blob = new Blob([jsonText], { type: 'application/json;charset=utf-8' })\n    const url = URL.createObjectURL(blob)\n    const link = document.createElement('a')\n    link.href = url\n    link.download = filePath.split('/').pop() || 'data.json'\n    document.body.appendChild(link)\n    link.click()\n    document.body.removeChild(link)\n    URL.revokeObjectURL(url)\n  }\n}\n\n/**\n * Imports JSON file and parses it to JavaScript value\n *\n * Reads JSON file from filesystem (Node.js only) and parses using native JSON.parse.\n * Returns the parsed JavaScript value (object, array, primitive).\n *\n * Features:\n * - UTF-8 encoding support for international characters\n * - Native JSON.parse for standard-compliant parsing\n * - Automatic type inference\n * - Whitespace and comment tolerance (standard JSON only)\n *\n * ⚠️ BROWSER LIMITATION: File reading from filesystem is not supported in browsers\n * for security reasons. For browser file uploads, use `readFileAsText()` with a File object\n * obtained from an input[type=\"file\"] element.\n *\n * @param filePath - Path to JSON file (Node.js only)\n * @param _options - Reserved for future options (currently unused)\n * @returns Promise<any> Parsed JavaScript value (object, array, primitive, null)\n *\n * @example\n * ```typescript\n * // Basic import - Node.js only\n * const config = await importJSON('./config/app.json')\n * // Returns: { database: { host: 'localhost', port: 5432 }, ... }\n *\n * console.log(config.database.host)  // 'localhost'\n *\n * // Array import\n * const users = await importJSON('./data/users.json')\n * // Returns: [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]\n *\n * // Primitive values (valid JSON)\n * const version = await importJSON('./version.json')  // \"1.2.3\"\n * const enabled = await importJSON('./feature.json')   // true\n * const count = await importJSON('./count.json')       // 42\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Load configuration with fallback\n * async function loadConfiguration(configPath: string): Promise<AppConfig> {\n *   try {\n *     const config = await importJSON(configPath)\n *\n *     // Validate loaded config\n *     if (!config.database || !config.database.host) {\n *       throw new Error('Invalid configuration: missing database.host')\n *     }\n *\n *     return config\n *   } catch (error) {\n *     console.warn(`Failed to load config from ${configPath}:`, error)\n *     console.log('Using default configuration')\n *     return getDefaultConfig()\n *   }\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Restore configuration backup\n * async function restoreBackup(backupFile: string) {\n *   console.log(`Restoring configuration from ${backupFile}...`)\n *\n *   const backup = await importJSON(`./backups/${backupFile}`)\n *\n *   // Verify backup integrity\n *   if (!backup.timestamp || !backup.config) {\n *     throw new Error('Invalid backup file format')\n *   }\n *\n *   // Restore configuration\n *   await saveConfiguration(backup.config)\n *\n *   console.log(`✅ Configuration restored from ${backup.timestamp}`)\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Browser alternative using File API\n * // HTML: <input type=\"file\" id=\"jsonFile\" accept=\".json\">\n *\n * document.getElementById('jsonFile').addEventListener('change', async (e) => {\n *   const file = e.target.files[0]\n *\n *   // Read file content\n *   const content = await readFileAsText(file)\n *\n *   // Parse JSON\n *   try {\n *     const data = JSON.parse(content)\n *     console.log('Imported JSON:', data)\n *   } catch (error) {\n *     console.error('Invalid JSON file:', error)\n *   }\n * })\n * ```\n *\n * @example\n * ```typescript\n * // Handle parsing errors\n * async function safeImportJSON(filePath: string): Promise<any | null> {\n *   try {\n *     return await importJSON(filePath)\n *   } catch (error) {\n *     if (error.message.includes('not supported in browser')) {\n *       console.error('Use File API for browser uploads')\n *     } else if (error.code === 'ENOENT') {\n *       console.error(`File not found: ${filePath}`)\n *     } else if (error instanceof SyntaxError) {\n *       console.error(`Invalid JSON syntax in ${filePath}:`, error.message)\n *     } else {\n *       console.error('JSON import failed:', error)\n *     }\n *     return null\n *   }\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Type-safe import with validation\n * interface DatabaseConfig {\n *   host: string\n *   port: number\n *   database: string\n * }\n *\n * async function loadDatabaseConfig(path: string): Promise<DatabaseConfig> {\n *   const raw = await importJSON(path)\n *\n *   // Runtime validation\n *   if (typeof raw.host !== 'string' || typeof raw.port !== 'number') {\n *     throw new Error('Invalid database configuration structure')\n *   }\n *\n *   return raw as DatabaseConfig\n * }\n * ```\n *\n * @throws {Error} 'JSON import not supported in browser' when called in browser environment\n * @throws {SyntaxError} If file contains invalid JSON syntax\n * @throws {Error} File system errors (ENOENT, EACCES, etc.) in Node.js\n * @see {@link exportJSON} for exporting JSON files\n * @see {@link readFileAsText} for browser file reading\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse JSON.parse Documentation}\n */\nexport async function importJSON(filePath: string, _options?: any): Promise<any> {\n  // ✅ Input validation\n  if (!filePath || typeof filePath !== 'string' || filePath.trim() === '') {\n    throw new TypeError('File path must be a non-empty string')\n  }\n\n  if (isNode()) {\n    const fs = await import('fs/promises')\n    const content = await fs.readFile(filePath, { encoding: 'utf-8' })\n\n    // ✅ Validate content is not empty\n    const trimmed = content.trim()\n    if (trimmed === '') {\n      throw new SyntaxError('JSON file is empty')\n    }\n\n    // ✅ Better error message for invalid JSON\n    try {\n      return JSON.parse(content)\n    } catch (error) {\n      if (error instanceof SyntaxError) {\n        throw new SyntaxError(`Invalid JSON in file ${filePath}: ${error.message}`)\n      }\n      throw error\n    }\n  } else {\n    throw new Error(\n      'JSON import not supported in browser. Use readFileAsText() with a File object.'\n    )\n  }\n}\n","/**\n * Environment detection utilities for universal browser/Node.js compatibility\n */\n\n/**\n * Detailed criteria used for environment debugging and analysis\n */\nexport interface EnvironmentCriteria {\n  /** True if hostname is localhost, 127.0.0.1, ::1, or .localhost/.local domain */\n  isLocalhost: boolean\n  /** True if hostname is within private IP ranges (10.x, 192.168.x, 172.16-31.x) */\n  isPrivateIP: boolean\n  /** True if port is in development range (3000-9999) */\n  isDevelopmentPort: boolean\n  /** True if development tools are detected (Vue DevTools, __DEV__ global) */\n  hasDevtools: boolean\n  /** Current NODE_ENV value (Node.js only) */\n  nodeEnv?: string\n}\n\n/**\n * Complete environment information with platform detection and debugging criteria\n */\nexport interface EnvironmentInfo {\n  /** Runtime platform: 'browser', 'node', or 'unknown' */\n  platform: 'browser' | 'node' | 'unknown'\n  /** Detected environment: 'development', 'production', or 'test' */\n  environment: 'development' | 'production' | 'test'\n  /** Protocol used (http/https) - from location or request headers */\n  protocol?: string\n  /** Hostname - from location or request headers */\n  hostname?: string\n  /** Browser user agent string (browser only) */\n  userAgent?: string\n  /** Detailed debugging criteria */\n  criteria?: EnvironmentCriteria\n}\n\n/**\n * Detects if the current runtime is Node.js environment\n *\n * Checks for the presence of Node.js-specific globals (process, process.versions.node)\n * and absence of browser globals (window).\n *\n * @returns True if running in Node.js, false otherwise\n *\n * @example\n * ```typescript\n * if (isNodeEnvironment()) {\n *   // Node.js specific code\n *   const fs = require('fs')\n * }\n * ```\n */\nexport function isNodeEnvironment(): boolean {\n  return typeof window === 'undefined' && typeof process !== 'undefined' && !!process.versions?.node\n}\n\n/**\n * Detects if the current runtime is a browser environment\n *\n * Checks for the presence of browser-specific globals (window, document).\n * Also handles testing environments that may mock these globals.\n *\n * @returns True if running in browser, false otherwise\n *\n * @example\n * ```typescript\n * if (isBrowserEnvironment()) {\n *   // Browser specific code\n *   const url = window.location.href\n * }\n * ```\n */\nexport function isBrowserEnvironment(): boolean {\n  // Check both global.window (for tests) and window (for actual browser)\n  const win = typeof window !== 'undefined' ? window : (global as any).window\n  const doc = typeof document !== 'undefined' ? document : (global as any).document\n  return typeof win !== 'undefined' && win !== null && typeof doc !== 'undefined' && doc !== null\n}\n\n/**\n * Detects if the application is running in development mode\n *\n * Uses sophisticated detection logic based on multiple criteria:\n * - Node.js: NODE_ENV variable, request headers (for Express), hostname/protocol analysis\n * - Browser: __DEV__ global, development ports (3000-9999), localhost/private IPs, dev tools\n *\n * Handles reverse proxies correctly by checking forwarded headers.\n *\n * @param req - Optional Express request object for server-side detection\n * @returns True if in development mode, false if production\n *\n * @example\n * ```typescript\n * // Node.js - simple check\n * if (isDevelopment()) {\n *   console.log('Development mode')\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Express - with request context\n * app.get('/api/status', (req, res) => {\n *   const isDev = isDevelopment(req)\n *   res.json({ environment: isDev ? 'dev' : 'prod' })\n * })\n * ```\n *\n * @example\n * ```typescript\n * // Browser - automatic detection\n * if (isDevelopment()) {\n *   // Enable debug logging, dev tools, etc.\n *   enableDebugMode()\n * }\n * ```\n */\nexport function isDevelopment(req?: any): boolean {\n  if (isNodeEnvironment()) {\n    // En Node.js, verificar NODE_ENV primero\n    if (process.env.NODE_ENV === 'production') {\n      return false\n    }\n    if (process.env.NODE_ENV === 'development') {\n      return true\n    }\n\n    // Si hay request object (Express), usar lógica de servidor\n    if (req) {\n      const protocol = detectProtocol(req)\n      const hostname = detectHostname(req)\n\n      return protocol === 'http' || isLocalhost(hostname) || isPrivateIP(hostname)\n    }\n\n    // Fallback para Node.js sin request\n    // NODE_ENV undefined se asume como development\n    return !process.env.NODE_ENV || process.env.NODE_ENV === 'development'\n  }\n\n  if (isBrowserEnvironment()) {\n    // Verificar variable global de desarrollo (webpack/vite)\n    if (\n      typeof (globalThis as any).__DEV__ !== 'undefined' &&\n      (globalThis as any).__DEV__ === true\n    ) {\n      return true\n    }\n\n    // Verificar si hay herramientas de desarrollo activas\n    if (\n      typeof window !== 'undefined' &&\n      (window as any).__VUE_DEVTOOLS_GLOBAL_HOOK__ &&\n      typeof location !== 'undefined' &&\n      isLocalhost(location.hostname)\n    ) {\n      return true\n    }\n\n    // Si location no está disponible, considerar como producción\n    if (typeof location === 'undefined') {\n      return false\n    }\n\n    const hostname = location.hostname || ''\n    const port = parseInt(location.port || '80')\n\n    // Criterios basados en hostname y puerto\n    const isDevelopmentPort = port >= 3000 && port <= 9999\n\n    // Solo considerar HTTP como desarrollo si el hostname también lo indica\n    const isHttpDevelopment =\n      location.protocol === 'http:' && (isLocalhost(hostname) || isPrivateIP(hostname))\n\n    return isLocalhost(hostname) || isPrivateIP(hostname) || isDevelopmentPort || isHttpDevelopment\n  }\n\n  return false\n}\n\n/**\n * Detects if the application is running in production mode\n *\n * Simple inverse of isDevelopment() with additional NODE_ENV validation for Node.js.\n *\n * @returns True if in production mode, false if development\n *\n * @example\n * ```typescript\n * if (isProduction()) {\n *   // Enable performance optimizations\n *   enableProductionMode()\n * }\n * ```\n */\nexport function isProduction(): boolean {\n  if (isNodeEnvironment()) {\n    return process.env.NODE_ENV === 'production'\n  }\n\n  // Browser: inverso de isDevelopment (que ya excluye test)\n  return !isDevelopment()\n}\n\n/**\n * Detects if the application is running in test mode\n *\n * Checks explicitly for NODE_ENV === 'test' in Node.js environments.\n * Vitest and Jest automatically set this value when running tests.\n *\n * @returns True if NODE_ENV is 'test', false otherwise\n *\n * @example\n * ```typescript\n * if (isTest()) {\n *   // Test-specific behavior (mocks, fixtures, etc.)\n *   enableTestMode()\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Conditional imports for testing\n * if (isTest()) {\n *   const { mockAPI } = await import('./test/mocks')\n *   mockAPI.setup()\n * }\n * ```\n */\nexport function isTest(): boolean {\n  if (isNodeEnvironment()) {\n    return process.env.NODE_ENV === 'test'\n  }\n\n  return false\n}\n\n/**\n * Detects if the application is NOT running in production mode\n *\n * Returns true for development, test, undefined, or any non-production environment.\n * Useful for enabling debugging, logging, or development-only features\n * across all non-production environments.\n *\n * @returns True if not in production (development, test, or undefined)\n *\n * @example\n * ```typescript\n * if (isNonProduction()) {\n *   // Enable debug logging for dev and test\n *   console.log('Debug mode enabled')\n *   enableVerboseLogging()\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Security: Disable strict checks in non-production\n * if (isNonProduction()) {\n *   allowSelfSignedCertificates()\n *   disableCSRFProtection()\n * }\n * ```\n */\nexport function isNonProduction(): boolean {\n  if (isNodeEnvironment()) {\n    return process.env.NODE_ENV !== 'production'\n  }\n\n  return !isProduction()\n}\n\n/**\n * Detects the protocol (HTTP/HTTPS) from browser location or request headers\n *\n * Handles reverse proxies correctly by checking forwarded headers in priority order:\n * 1. X-Forwarded-Proto (most common)\n * 2. X-Forwarded-Protocol\n * 3. X-Url-Scheme\n * 4. Front-End-Https\n * 5. CF-Visitor (Cloudflare specific)\n *\n * @param req - Optional Express request object with headers\n * @returns Protocol as 'http' or 'https'\n *\n * @example\n * ```typescript\n * // Browser usage\n * const protocol = detectProtocol() // 'https' from window.location\n * ```\n *\n * @example\n * ```typescript\n * // Express server with proxy\n * app.get('/api', (req, res) => {\n *   const protocol = detectProtocol(req) // Detects from X-Forwarded-Proto\n *   const fullUrl = `${protocol}://${req.get('host')}${req.path}`\n * })\n * ```\n */\nexport function detectProtocol(req?: any): 'http' | 'https' {\n  if (isBrowserEnvironment()) {\n    if (typeof location !== 'undefined') {\n      return location.protocol === 'https:' ? 'https' : 'http'\n    }\n    return 'https' // Default seguro para browser\n  }\n\n  if (req) {\n    // Headers comunes de proxies reversos en orden de prioridad\n    const forwardedProto = req.get?.('X-Forwarded-Proto') || req.headers?.['x-forwarded-proto']\n    const forwardedProtocol =\n      req.get?.('X-Forwarded-Protocol') || req.headers?.['x-forwarded-protocol']\n    const urlScheme = req.get?.('X-Url-Scheme') || req.headers?.['x-url-scheme']\n    const frontEndHttps = req.get?.('Front-End-Https') || req.headers?.['front-end-https']\n    const cloudflareVisitor = req.get?.('CF-Visitor') || req.headers?.['cf-visitor']\n\n    // Verificar headers de proxy\n    if (forwardedProto) {\n      return forwardedProto.split(',')[0].trim().toLowerCase() as 'http' | 'https'\n    }\n    if (forwardedProtocol) {\n      return forwardedProtocol.toLowerCase() as 'http' | 'https'\n    }\n    if (urlScheme) {\n      return urlScheme.toLowerCase() as 'http' | 'https'\n    }\n    if (frontEndHttps === 'on') {\n      return 'https'\n    }\n    if (cloudflareVisitor) {\n      try {\n        const visitor = JSON.parse(cloudflareVisitor)\n        if (visitor.scheme) {\n          return visitor.scheme.toLowerCase() as 'http' | 'https'\n        }\n      } catch (_e) {\n        // Ignorar errores de parsing JSON\n      }\n    }\n\n    // Fallback al protocolo directo\n    if (req.protocol) return req.protocol\n    if (req.secure) return 'https'\n  }\n\n  // Default para Node.js sin request context\n  return 'http'\n}\n\n/**\n * Extracts hostname from browser location or request headers\n *\n * Handles reverse proxies by checking forwarded headers in priority order:\n * 1. X-Forwarded-Host (most common, supports multiple hosts)\n * 2. X-Original-Host\n * 3. Host header\n *\n * Automatically strips port numbers and handles multiple comma-separated hosts.\n *\n * @param req - Optional Express request object with headers\n * @returns Hostname without port number\n *\n * @example\n * ```typescript\n * // Browser usage\n * const hostname = detectHostname() // 'example.com' from window.location\n * ```\n *\n * @example\n * ```typescript\n * // Express server behind proxy\n * app.get('/api', (req, res) => {\n *   const hostname = detectHostname(req) // 'api.example.com' from X-Forwarded-Host\n *   const isLocal = isLocalhost(hostname)\n * })\n * ```\n */\nexport function detectHostname(req?: any): string {\n  if (isBrowserEnvironment()) {\n    if (typeof location !== 'undefined') {\n      return location.hostname\n    }\n    return 'localhost'\n  }\n\n  if (req) {\n    // Headers comunes de proxies reversos en orden de prioridad\n    const forwardedHost = req.get?.('X-Forwarded-Host') || req.headers?.['x-forwarded-host']\n    const originalHost = req.get?.('X-Original-Host') || req.headers?.['x-original-host']\n    const host = req.get?.('Host') || req.headers?.['host']\n\n    // Verificar headers de proxy\n    if (forwardedHost) {\n      return forwardedHost.split(',')[0].trim().split(':')[0]\n    }\n    if (originalHost) {\n      return originalHost.split(':')[0]\n    }\n    if (host) {\n      return host.split(':')[0]\n    }\n\n    // Fallback al hostname directo\n    if (req.hostname) return req.hostname\n  }\n\n  // Default para Node.js sin request context\n  return 'localhost'\n}\n\n/**\n * Checks if a hostname represents localhost or local development\n *\n * Recognizes various localhost representations:\n * - 'localhost' (standard)\n * - '127.0.0.1' (IPv4 loopback)\n * - '::1' (IPv6 loopback)\n * - '*.localhost' (local development domains)\n * - '*.local' (mDNS local domains)\n *\n * @param hostname - Hostname to check\n * @returns True if hostname represents localhost\n *\n * @example\n * ```typescript\n * isLocalhost('localhost')        // true\n * isLocalhost('127.0.0.1')        // true\n * isLocalhost('app.localhost')    // true\n * isLocalhost('macbook.local')    // true\n * isLocalhost('example.com')      // false\n * ```\n */\nexport function isLocalhost(hostname: string): boolean {\n  return (\n    hostname === 'localhost' ||\n    hostname === '127.0.0.1' ||\n    hostname === '::1' ||\n    hostname.endsWith('.localhost') ||\n    hostname.endsWith('.local')\n  )\n}\n\n/**\n * Checks if a hostname is within private IP address ranges\n *\n * Recognizes private/internal IP ranges according to RFC 1918:\n * - IPv4: 10.x.x.x, 192.168.x.x, 172.16-31.x.x, 127.x.x.x (loopback)\n * - IPv6: ::1 (loopback), fc00::/7 (unique local), fe80::/10 (link-local)\n * - Also includes localhost detection\n *\n * @param hostname - Hostname or IP address to check\n * @returns True if hostname is private/local, false if public\n *\n * @example\n * ```typescript\n * isPrivateIP('192.168.1.1')      // true\n * isPrivateIP('10.0.0.1')         // true\n * isPrivateIP('172.16.0.1')       // true\n * isPrivateIP('localhost')        // true\n * isPrivateIP('8.8.8.8')          // false\n * isPrivateIP('example.com')      // false\n * ```\n */\nexport function isPrivateIP(hostname: string): boolean {\n  // IPv4 private ranges\n  const ipv4Patterns = [\n    /^10\\./, // 10.0.0.0/8\n    /^172\\.(1[6-9]|2[0-9]|3[0-1])\\./, // 172.16.0.0/12\n    /^192\\.168\\./, // 192.168.0.0/16\n    /^127\\./, // 127.0.0.0/8 (loopback)\n  ]\n\n  // IPv6 private/local ranges\n  const ipv6Patterns = [\n    /^::1$/, // IPv6 loopback\n    /^fc[0-9a-f]{2}:/i, // Unique local addresses\n    /^fd[0-9a-f]{2}:/i, // Unique local addresses\n    /^fe80:/i, // Link-local addresses\n  ]\n\n  return (\n    ipv4Patterns.some(pattern => pattern.test(hostname)) ||\n    ipv6Patterns.some(pattern => pattern.test(hostname)) ||\n    isLocalhost(hostname)\n  )\n}\n\n/**\n * Gathers complete environment information for debugging and analysis\n *\n * Returns comprehensive environment data including platform detection,\n * development/production status, protocol/hostname information, and\n * detailed debugging criteria.\n *\n * @param req - Optional Express request object for server-side context\n * @returns Complete environment information object\n *\n * @example\n * ```typescript\n * // Basic usage\n * const env = getEnvironmentInfo()\n * console.log(env.platform)     // 'node' | 'browser' | 'unknown'\n * console.log(env.environment)  // 'development' | 'production' | 'test'\n * ```\n *\n * @example\n * ```typescript\n * // Express server usage\n * app.get('/api/debug', (req, res) => {\n *   const envInfo = getEnvironmentInfo(req)\n *   res.json({\n *     platform: envInfo.platform,\n *     isDev: envInfo.environment === 'development',\n *     protocol: envInfo.protocol,\n *     host: envInfo.hostname,\n *     criteria: envInfo.criteria\n *   })\n * })\n * ```\n *\n * @example\n * ```typescript\n * // Conditional features based on environment\n * const env = getEnvironmentInfo()\n * if (env.criteria?.hasDevtools) {\n *   enableVueDevtools()\n * }\n * if (env.criteria?.isDevelopmentPort) {\n *   enableHotReload()\n * }\n * ```\n */\nexport function getEnvironmentInfo(req?: any): EnvironmentInfo {\n  const platform = isNodeEnvironment() ? 'node' : isBrowserEnvironment() ? 'browser' : 'unknown'\n\n  let environment: EnvironmentInfo['environment'] = 'production'\n  if (isNodeEnvironment()) {\n    const nodeEnv = process.env.NODE_ENV\n    if (nodeEnv === 'development' || nodeEnv === 'test') {\n      environment = nodeEnv\n    }\n  } else if (isDevelopment()) {\n    environment = 'development'\n  }\n\n  const protocol = detectProtocol(req)\n  const hostname = detectHostname(req)\n\n  const info: EnvironmentInfo = {\n    platform,\n    environment,\n    protocol,\n    hostname,\n  }\n\n  if (isBrowserEnvironment() && typeof navigator !== 'undefined') {\n    info.userAgent = navigator.userAgent\n  }\n\n  // Criterios detallados para debugging\n  const criteria: EnvironmentCriteria = {\n    isLocalhost: isLocalhost(hostname),\n    isPrivateIP: isPrivateIP(hostname),\n    isDevelopmentPort: false,\n    hasDevtools: false,\n  }\n\n  if (isBrowserEnvironment() && typeof location !== 'undefined') {\n    const port = parseInt(location.port || '80')\n    criteria.isDevelopmentPort = port >= 3000 && port <= 9999\n    criteria.hasDevtools = !!(\n      typeof window !== 'undefined' && (window as any).__VUE_DEVTOOLS_GLOBAL_HOOK__\n    )\n  }\n\n  if (isNodeEnvironment()) {\n    criteria.nodeEnv = process.env.NODE_ENV || 'undefined'\n  }\n\n  info.criteria = criteria\n\n  return info\n}\n\n/**\n * Alias for isNodeEnvironment() - detects Node.js runtime\n * @see {@link isNodeEnvironment}\n */\nexport const isNode = isNodeEnvironment\n\n/**\n * Alias for isBrowserEnvironment() - detects browser runtime\n * @see {@link isBrowserEnvironment}\n */\nexport const isBrowser = isBrowserEnvironment\n\n/**\n * Parses environment variable string values to their native JavaScript types\n *\n * Automatically detects and converts:\n * - Booleans: 'true', 'false', 'yes', 'no', '1', '0'\n * - Numbers: '42', '3.14', '-100'\n * - JSON arrays: '[1,2,3]', '[\"a\",\"b\"]'\n * - JSON objects: '{\"key\":\"value\"}'\n * - Comma-separated arrays: 'item1,item2,item3' (when not valid JSON)\n * - null/undefined: 'null', 'undefined', empty string\n *\n * Falls back to original string if no conversion applies.\n *\n * @param value - Environment variable string value to parse\n * @returns Parsed value with appropriate native type\n *\n * @example\n * ```typescript\n * // Boolean conversion\n * parseEnvValue('true')      // true\n * parseEnvValue('false')     // false\n * parseEnvValue('yes')       // true\n * parseEnvValue('1')         // true (as boolean)\n *\n * // Number conversion\n * parseEnvValue('42')        // 42\n * parseEnvValue('3.14')      // 3.14\n * parseEnvValue('-100')      // -100\n *\n * // JSON arrays\n * parseEnvValue('[1,2,3]')   // [1, 2, 3]\n * parseEnvValue('[\"a\",\"b\"]') // ['a', 'b']\n *\n * // JSON objects\n * parseEnvValue('{\"port\":3000,\"host\":\"localhost\"}')\n * // { port: 3000, host: 'localhost' }\n *\n * // Comma-separated arrays (fallback when not JSON)\n * parseEnvValue('red,green,blue')  // ['red', 'green', 'blue']\n *\n * // Null/undefined\n * parseEnvValue('null')      // null\n * parseEnvValue('undefined') // undefined\n * parseEnvValue('')          // undefined\n *\n * // Strings (no conversion)\n * parseEnvValue('hello')     // 'hello'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world usage with process.env\n * const config = {\n *   debug: parseEnvValue(process.env.DEBUG),           // 'true' → true\n *   port: parseEnvValue(process.env.PORT),             // '3000' → 3000\n *   features: parseEnvValue(process.env.FEATURES),     // 'auth,api' → ['auth', 'api']\n *   database: parseEnvValue(process.env.DB_CONFIG),    // '{\"host\":\"localhost\"}' → object\n * }\n * ```\n */\nexport function parseEnvValue(value: string | undefined): any {\n  // Handle null/undefined/empty\n  if (value === undefined || value === null || value === '') {\n    return undefined\n  }\n\n  const trimmed = value.trim()\n\n  // Handle explicit null/undefined strings\n  if (trimmed === 'null') return null\n  if (trimmed === 'undefined') return undefined\n\n  // Handle booleans\n  const lowerValue = trimmed.toLowerCase()\n  if (lowerValue === 'true' || lowerValue === 'yes') return true\n  if (lowerValue === 'false' || lowerValue === 'no') return false\n\n  // Handle boolean-like numbers\n  if (trimmed === '1') return true\n  if (trimmed === '0') return false\n\n  // Try parsing as number (but not if it starts with 0 and has more digits - could be octal/string)\n  if (/^-?\\d+\\.?\\d*$/.test(trimmed)) {\n    // Avoid treating leading-zero strings as numbers (e.g., postal codes '01234')\n    if (trimmed.length > 1 && trimmed[0] === '0' && trimmed[1] !== '.') {\n      return trimmed // Keep as string (e.g., '01234')\n    }\n    const num = Number(trimmed)\n    if (!isNaN(num)) return num\n  }\n\n  // Try parsing as JSON (arrays, objects)\n  if (\n    (trimmed.startsWith('[') && trimmed.endsWith(']')) ||\n    (trimmed.startsWith('{') && trimmed.endsWith('}'))\n  ) {\n    try {\n      return JSON.parse(trimmed)\n    } catch {\n      // Not valid JSON, continue to next check\n    }\n  }\n\n  // Try parsing comma-separated values as array\n  if (trimmed.includes(',')) {\n    const parts = trimmed.split(',').map(s => s.trim())\n    // Only convert to array if all parts are non-empty\n    if (parts.every(p => p.length > 0)) {\n      return parts\n    }\n  }\n\n  // Return as-is string\n  return trimmed\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACsDO,SAAS,oBAA6B;AAC3C,SAAO,OAAO,WAAW,eAAe,OAAO,YAAY,eAAe,CAAC,CAAC,QAAQ,UAAU;AAChG;AAuhBO,IAAM,SAAS;;;AD3ctB,eAAsB,WACpB,MACA,UACA,SACe;AAEf,MAAI,SAAS,QAAQ,SAAS,QAAW;AACvC,UAAM,IAAI,UAAU,kCAAkC;AAAA,EACxD;AAEA,MAAI,CAAC,YAAY,OAAO,aAAa,YAAY,SAAS,KAAK,MAAM,IAAI;AACvE,UAAM,IAAI,UAAU,sCAAsC;AAAA,EAC5D;AAEA,QAAM,EAAE,SAAS,EAAE,IAAI,WAAW,CAAC;AAGnC,MAAI;AACJ,MAAI;AACF,eAAW,KAAK,UAAU,MAAM,MAAM,MAAM;AAAA,EAC9C,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa,MAAM,QAAQ,SAAS,UAAU,GAAG;AACpE,YAAM,IAAI,UAAU,gDAAgD;AAAA,IACtE;AACA,UAAM;AAAA,EACR;AAEA,MAAI,OAAO,GAAG;AACZ,UAAM,KAAK,MAAM,OAAO,aAAa;AACrC,UAAM,GAAG,UAAU,UAAU,UAAU,EAAE,UAAU,QAAQ,CAAC;AAAA,EAC9D,OAAO;AACL,UAAM,OAAO,IAAI,KAAK,CAAC,QAAQ,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAC5E,UAAM,MAAM,IAAI,gBAAgB,IAAI;AACpC,UAAM,OAAO,SAAS,cAAc,GAAG;AACvC,SAAK,OAAO;AACZ,SAAK,WAAW,SAAS,MAAM,GAAG,EAAE,IAAI,KAAK;AAC7C,aAAS,KAAK,YAAY,IAAI;AAC9B,SAAK,MAAM;AACX,aAAS,KAAK,YAAY,IAAI;AAC9B,QAAI,gBAAgB,GAAG;AAAA,EACzB;AACF;AAuJA,eAAsB,WAAW,UAAkB,UAA8B;AAE/E,MAAI,CAAC,YAAY,OAAO,aAAa,YAAY,SAAS,KAAK,MAAM,IAAI;AACvE,UAAM,IAAI,UAAU,sCAAsC;AAAA,EAC5D;AAEA,MAAI,OAAO,GAAG;AACZ,UAAM,KAAK,MAAM,OAAO,aAAa;AACrC,UAAM,UAAU,MAAM,GAAG,SAAS,UAAU,EAAE,UAAU,QAAQ,CAAC;AAGjE,UAAM,UAAU,QAAQ,KAAK;AAC7B,QAAI,YAAY,IAAI;AAClB,YAAM,IAAI,YAAY,oBAAoB;AAAA,IAC5C;AAGA,QAAI;AACF,aAAO,KAAK,MAAM,OAAO;AAAA,IAC3B,SAAS,OAAO;AACd,UAAI,iBAAiB,aAAa;AAChC,cAAM,IAAI,YAAY,wBAAwB,QAAQ,KAAK,MAAM,OAAO,EAAE;AAAA,MAC5E;AACA,YAAM;AAAA,IACR;AAAA,EACF,OAAO;AACL,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/node/math.js

@@ -0,0 +1,413 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/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
+});
+module.exports = __toCommonJS(math_exports);
+var lodash = __toESM(require("lodash"));
+
+// src/number.ts
+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 } = lodash;
+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 };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateAggregations,
+  calculateAnnuityPayment,
+  calculateCorrelation,
+  calculateEuclideanDistance,
+  calculateFutureValue,
+  calculateHistogram,
+  calculateIQR,
+  calculateIRR,
+  calculateManhattanDistance,
+  calculateMedian,
+  calculateMode,
+  calculateNPV,
+  calculatePercentile,
+  calculatePresentValue,
+  calculateQuartiles,
+  calculateStandardDeviation,
+  calculateTrendSlope,
+  calculateVariance,
+  detectOutliers,
+  normalizeToRange,
+  scaleToRange,
+  simpleKMeans
+});
+//# sourceMappingURL=math.js.map