brew-tui 0.1.0

package/build/chunk-P6PTN4HR.js

@@ -0,0 +1,1140 @@
+// src/i18n/index.ts
+import { create } from "zustand";
+
+// src/i18n/en.ts
+var en = {
+  // ── App chrome ──
+  app_title: "Brew-TUI",
+  pro_badge: "PRO",
+  app_version: "Brew-TUI v{{version}}",
+  // ── View labels (header tab bar) ──
+  view_dashboard: "Dashboard",
+  view_installed: "Installed",
+  view_search: "Search",
+  view_outdated: "Outdated",
+  view_packageInfo: "Pkg Info",
+  view_services: "Services",
+  view_doctor: "Doctor",
+  view_profiles: "Profiles",
+  view_smartCleanup: "Cleanup",
+  view_history: "History",
+  view_securityAudit: "Security",
+  view_account: "Account",
+  // ── Keyboard hint actions ──
+  hint_navigate: "navigate",
+  hint_next: "next",
+  hint_quit: "quit",
+  hint_filter: "filter",
+  hint_info: "info",
+  hint_toggle: "toggle",
+  hint_typeToSearch: "type to search",
+  hint_install: "install",
+  hint_uninstall: "uninstall",
+  hint_upgrade: "upgrade",
+  hint_upgradeAll: "upgrade all",
+  hint_back: "back",
+  hint_start: "start",
+  hint_stop: "stop",
+  hint_restart: "restart",
+  hint_refresh: "refresh",
+  hint_new: "new",
+  hint_details: "details",
+  hint_import: "import",
+  hint_delete: "delete",
+  hint_clean: "clean",
+  hint_all: "all",
+  hint_search: "search",
+  hint_clear: "clear",
+  hint_scan: "scan",
+  hint_expand: "expand",
+  hint_cancel: "cancel",
+  hint_force: "force uninstall (ignore deps)",
+  hint_rescan: "rescan",
+  hint_deactivate: "deactivate",
+  hint_importProfile: "import this profile",
+  hint_lang: "lang",
+  hint_replay: "replay",
+  hint_edit: "edit",
+  hint_pin: "pin/unpin",
+  // ── Loading / progress ──
+  loading_default: "Loading...",
+  loading_fetchingBrew: "Fetching Homebrew data...",
+  loading_installed: "Loading installed packages...",
+  loading_outdated: "Checking for outdated packages...",
+  loading_services: "Loading services...",
+  loading_doctor: "Running brew doctor... (this may take a moment)",
+  loading_profiles: "Loading profiles...",
+  loading_cleanup: "Analyzing packages... (checking disk usage)",
+  loading_history: "Loading history...",
+  loading_security: "Scanning packages against OSV vulnerability database...",
+  loading_searching: "Searching...",
+  loading_package: "Loading {{name}}...",
+  // ── Confirm dialog ──
+  confirm_yes: "[Y]es",
+  confirm_no: "[N]o",
+  // ── Error ──
+  error_prefix: "Error: ",
+  // ── Common ──
+  common_andMore: "...and {{count}} more",
+  common_exit: "(exit {{code}})",
+  common_yes: "yes",
+  common_no: "no",
+  // ── Relative time ──
+  time_justNow: "just now",
+  time_minutesAgo: "{{n}}m ago",
+  time_hoursAgo: "{{n}}h ago",
+  time_daysAgo: "{{n}}d ago",
+  time_monthsAgo: "{{n}}mo ago",
+  // ── Badges ──
+  badge_outdated: "outdated",
+  badge_pinned: "pinned",
+  badge_kegOnly: "keg-only",
+  badge_dep: "dep",
+  badge_installed: "installed",
+  badge_deprecated: "deprecated",
+  badge_ok: "ok",
+  badge_fail: "fail",
+  badge_error: "error",
+  // ── Dashboard ──
+  dashboard_overview: "Overview",
+  dashboard_formulae: "Formulae",
+  dashboard_casks: "Casks",
+  dashboard_outdated: "Outdated",
+  dashboard_services: "Services",
+  dashboard_systemInfo: "System Info",
+  dashboard_homebrew: "Homebrew:",
+  dashboard_prefix: "Prefix:",
+  dashboard_updated: "Updated:",
+  dashboard_outdatedPackages: "Outdated Packages",
+  dashboard_serviceErrors: "Service Errors",
+  // ── Installed ──
+  installed_formulaeCount: "Formulae ({{count}})",
+  installed_casksCount: "Casks ({{count}})",
+  installed_filterDisplay: 'Filter: "{{query}}" ({{count}} matches)',
+  installed_noPackages: "No packages found",
+  installed_confirmUninstall: "Uninstall {{name}}?",
+  // ── Search ──
+  search_placeholder: "Search Homebrew packages... (enter to search)",
+  search_resultsFor: "Results for",
+  search_escToClear: "(esc to clear)",
+  search_installing: "Installing package...",
+  search_installComplete: "Installation complete!",
+  search_confirmInstall: "Install {{name}}?",
+  search_formulaeHeader: "=== Formulae ({{count}})",
+  search_casksHeader: "=== Casks ({{count}})",
+  search_noResults: "No results found",
+  // ── Outdated ──
+  outdated_title: "Outdated Packages ({{count}})",
+  outdated_upgrading: "Upgrading...",
+  outdated_upgradeComplete: "Upgrade complete!",
+  outdated_pressRefresh: "(press r to refresh)",
+  outdated_upToDate: "Everything is up to date!",
+  outdated_confirmAll: "Upgrade all {{count}} packages?",
+  outdated_confirmSingle: "Upgrade {{name}}?",
+  outdated_pinned: "[pinned]",
+  // ── Package Info ──
+  pkgInfo_noPackage: "No package selected. Go to Installed and press Enter on a package.",
+  pkgInfo_notFound: "Package not found",
+  pkgInfo_installing: "Installing {{name}}...",
+  pkgInfo_uninstalling: "Uninstalling {{name}}...",
+  pkgInfo_upgrading: "Upgrading {{name}}...",
+  pkgInfo_done: "Done!",
+  pkgInfo_confirmInstall: "install {{name}}?",
+  pkgInfo_confirmUninstall: "uninstall {{name}}?",
+  pkgInfo_confirmUpgrade: "upgrade {{name}}?",
+  pkgInfo_details: "Details",
+  pkgInfo_homepage: "Homepage:",
+  pkgInfo_license: "License:",
+  pkgInfo_tap: "Tap:",
+  pkgInfo_stable: "Stable:",
+  pkgInfo_installed: "Installed:",
+  pkgInfo_bottle: "Bottle:",
+  pkgInfo_onRequest: "On request:",
+  pkgInfo_noDependency: "no (dependency)",
+  pkgInfo_dependencies: "Dependencies ({{count}})",
+  pkgInfo_caveats: "Caveats",
+  // ── Services ──
+  services_title: "Homebrew Services",
+  services_titleCount: "Homebrew Services ({{count}})",
+  services_noServices: "No services found",
+  services_name: "Name",
+  services_status: "Status",
+  services_user: "User",
+  services_processing: "Processing...",
+  services_confirmStop: "Stop service {{name}}?",
+  services_confirmRestart: "Restart service {{name}}?",
+  // ── Doctor ──
+  doctor_title: "Homebrew Doctor",
+  doctor_clean: "Your system is ready to brew.",
+  doctor_warningsNotCaptured: "Doctor finished with warnings but none were captured.",
+  // ── Profiles ──
+  profiles_title: "Package Profiles ({{count}})",
+  profiles_importTitle: "Importing profile...",
+  profiles_importComplete: "Import complete. Press any key.",
+  profiles_createName: "Create Profile \u2014 Name:",
+  profiles_namePlaceholder: "e.g. work, personal, project-x",
+  profiles_createDesc: 'Create Profile "{{name}}" \u2014 Description:',
+  profiles_descPlaceholder: "Brief description of this setup",
+  profiles_created: "Created: {{date}}",
+  profiles_formulaeCount: "Formulae ({{count}})",
+  profiles_casksCount: "Casks ({{count}})",
+  profiles_confirmDelete: 'Delete profile "{{name}}"?',
+  profiles_noProfiles: "No profiles saved yet.",
+  profiles_press: "Press",
+  profiles_exportHint: "to export your current setup as a profile.",
+  profiles_editName: "Edit Profile \u2014 Name:",
+  profiles_editDesc: 'Edit Profile "{{name}}" \u2014 Description:',
+  // ── Smart Cleanup ──
+  cleanup_title: "Smart Cleanup",
+  cleanup_cleaning: "Cleaning up...",
+  cleanup_complete: "Cleanup complete! Press r to re-analyze.",
+  cleanup_orphans: "Orphans",
+  cleanup_reclaimable: "Reclaimable",
+  cleanup_selected: "Selected",
+  cleanup_confirmUninstall: "Uninstall {{count}} packages?",
+  cleanup_confirmForce: "Some packages have dependencies. Force uninstall {{count}} packages? (ignores dependencies)",
+  cleanup_depError: "Some packages could not be removed due to dependencies.",
+  cleanup_systemClean: "No orphaned packages found. Your system is clean!",
+  // ── History ──
+  history_title: "Action History ({{count}})",
+  history_filterLabel: "filter: {{filter}}",
+  history_searchPlaceholder: "Search packages...",
+  history_confirmClear: "Clear all {{count}} history entries?",
+  history_noEntries: "No history entries",
+  history_noEntriesFor: 'No history entries for "{{filter}}"',
+  history_all: "(all)",
+  history_actionInstall: "install",
+  history_actionUninstall: "uninstall",
+  history_actionUpgrade: "upgrade",
+  history_actionUpgradeAll: "upgrade-all",
+  history_confirmReplay: "Re-run: {{action}} {{name}}?",
+  history_replayAll: "Re-run: upgrade all packages?",
+  // ── Security Audit ──
+  security_title: "Security Audit",
+  security_scanned: "Scanned",
+  security_vulnerable: "Vulnerable",
+  security_critical: "Critical",
+  security_high: "High",
+  security_medium: "Medium",
+  security_noVulns: "No known vulnerabilities found in your installed packages!",
+  security_fixedIn: "Fixed in: {{version}}",
+  security_confirmUpgrade: "Upgrade {{name}} to fix vulnerabilities?",
+  // ── Account ──
+  account_title: "Account & License",
+  account_confirmDeactivate: "Deactivate your Pro license on this machine?",
+  account_statusLabel: "Status:",
+  account_pro: "[Pro]",
+  account_free: "[Free]",
+  account_expired: "[Expired]",
+  account_validating: "[Validating...]",
+  account_emailLabel: "Email:",
+  account_nameLabel: "Name:",
+  account_planLabel: "Plan:",
+  account_monthlyPrice: "9\u20AC/month",
+  account_yearlyPrice: "49\u20AC/year",
+  account_keyLabel: "Key:",
+  account_expiresLabel: "Expires:",
+  account_activatedLabel: "Activated:",
+  account_upgradeTitle: "Upgrade to Brew-TUI Pro",
+  account_unlockDesc: "Unlock Profiles, Smart Cleanup, History, Security Audit, and BrewBar (macOS menu bar companion).",
+  account_pricing: "9\u20AC/month or 49\u20AC/year",
+  account_runActivate: "Run:",
+  account_activateCmd: "brew-tui activate <key>",
+  account_licenseExpired: "Your license has expired. Renew to continue using Pro features.",
+  account_deactivating: "Deactivating...",
+  // ── Upgrade Prompt ──
+  upgrade_proFeature: "{{title}} \u2014 Pro Feature",
+  upgrade_profiles: "Package Profiles",
+  upgrade_profilesDesc: "Export and import your Homebrew setup across machines. Save named profiles for work, personal, or project-specific configurations.",
+  upgrade_cleanup: "Smart Cleanup",
+  upgrade_cleanupDesc: "Find orphaned packages, analyze disk usage per package, and reclaim disk space with one-click intelligent cleanup.",
+  upgrade_history: "Action History",
+  upgrade_historyDesc: "Track every install, uninstall, and upgrade with timestamps. Search and filter your package management history.",
+  upgrade_security: "Security Audit",
+  upgrade_securityDesc: "Scan installed packages against known vulnerabilities (CVEs). See severity levels, affected versions, and available fixes.",
+  upgrade_pricing: "9\u20AC/month or 49\u20AC/year",
+  upgrade_activateWith: "Activate with:",
+  upgrade_activateCmd: "brew-tui activate <your-license-key>",
+  upgrade_proLabel: "Brew-TUI Pro \u2014 9\u20AC/month or 49\u20AC/year \u2014 Includes BrewBar for macOS",
+  // ── Progress Log ──
+  progress_noOutput: "No output yet",
+  // ── Search Input ──
+  searchInput_placeholder: "Type to filter...",
+  // ── Profile Manager ──
+  profileMgr_tapping: "Tapping {{name}}...",
+  profileMgr_installing: "Installing {{name}}...",
+  profileMgr_installingCask: "Installing cask {{name}}...",
+  profileMgr_importDone: "Done! Installed {{count}} packages.",
+  // ── CLI ──
+  cli_usageActivate: "Usage: brew-tui activate <license-key>",
+  cli_activated: "\u2714 Pro activated for {{email}}",
+  cli_plan: "  Plan: {{plan}}",
+  cli_expires: "  Expires: {{date}}",
+  cli_activationFailed: "\u2718 Activation failed: {{error}}",
+  cli_noLicense: "No active license found.",
+  cli_deactivated: "\u2714 License deactivated.",
+  cli_planFree: "Plan: Free",
+  cli_planPro: "Plan: Pro",
+  cli_confirmDeactivate: "Deactivate your Pro license on this machine? (y/N): ",
+  cli_deactivateCancelled: "Deactivation cancelled.",
+  cli_upgradeHint: "Run `brew-tui activate <key>` to upgrade to Pro.",
+  cli_email: "Email: {{email}}",
+  cli_status: "Status: {{status}}",
+  cli_rateLimited: "Too many activation attempts. Try again in {{minutes}} minutes.",
+  cli_cooldown: "Please wait before trying again.",
+  cli_brewbarInstalling: "Downloading BrewBar...",
+  cli_brewbarInstalled: "\u2714 BrewBar installed to /Applications/BrewBar.app",
+  cli_brewbarAlreadyInstalled: "BrewBar is already installed. Use --force to reinstall.",
+  cli_brewbarUninstalled: "\u2714 BrewBar removed from /Applications.",
+  cli_brewbarNotInstalled: "BrewBar is not installed.",
+  cli_brewbarProRequired: "\u2718 BrewBar requires a Pro license.\n  Run: brew-tui activate <key>",
+  cli_brewbarMacOnly: "\u2718 BrewBar is only available on macOS.",
+  cli_brewbarDownloadFailed: "\u2718 Failed to download BrewBar: {{error}}",
+  // ── License degradation (Layer 15) ──
+  license_offlineWarning: "Your license has not been validated for {{days}} days. Please connect to the internet.",
+  // ── Plurals ──
+  plural_vulns_one: "({{count}} vuln)",
+  plural_vulns_other: "({{count}} vulns)",
+  plural_warnings_one: "{{count}} warning",
+  plural_warnings_other: "{{count}} warnings",
+  // ── Scroll indicators ──
+  scroll_moreAbove: "\u2191 {{count}} more",
+  scroll_moreBelow: "\u2193 {{count}} more"
+};
+var en_default = en;
+
+// src/i18n/es.ts
+var es = {
+  // ── App chrome ──
+  app_title: "Brew-TUI",
+  pro_badge: "PRO",
+  app_version: "Brew-TUI v{{version}}",
+  // ── View labels (header tab bar) ──
+  view_dashboard: "Inicio",
+  view_installed: "Instalados",
+  view_search: "Buscar",
+  view_outdated: "Desactual.",
+  view_packageInfo: "Info Paq.",
+  view_services: "Servicios",
+  view_doctor: "Doctor",
+  view_profiles: "Perfiles",
+  view_smartCleanup: "Limpieza",
+  view_history: "Historial",
+  view_securityAudit: "Seguridad",
+  view_account: "Cuenta",
+  // ── Keyboard hint actions ──
+  hint_navigate: "navegar",
+  hint_next: "siguiente",
+  hint_quit: "salir",
+  hint_filter: "filtrar",
+  hint_info: "info",
+  hint_toggle: "cambiar",
+  hint_typeToSearch: "escriba para buscar",
+  hint_install: "instalar",
+  hint_uninstall: "desinstalar",
+  hint_upgrade: "actualizar",
+  hint_upgradeAll: "actualizar todo",
+  hint_back: "volver",
+  hint_start: "iniciar",
+  hint_stop: "detener",
+  hint_restart: "reiniciar",
+  hint_refresh: "refrescar",
+  hint_new: "nuevo",
+  hint_details: "detalles",
+  hint_import: "importar",
+  hint_delete: "eliminar",
+  hint_clean: "limpiar",
+  hint_all: "todo",
+  hint_search: "buscar",
+  hint_clear: "borrar",
+  hint_scan: "escanear",
+  hint_expand: "expandir",
+  hint_cancel: "cancelar",
+  hint_force: "forzar (ignorar deps)",
+  hint_rescan: "re-escanear",
+  hint_deactivate: "desactivar",
+  hint_importProfile: "importar este perfil",
+  hint_lang: "idioma",
+  hint_replay: "repetir",
+  hint_edit: "editar",
+  hint_pin: "fijar/desfijar",
+  // ── Loading / progress ──
+  loading_default: "Cargando...",
+  loading_fetchingBrew: "Obteniendo datos de Homebrew...",
+  loading_installed: "Cargando paquetes instalados...",
+  loading_outdated: "Buscando paquetes desactualizados...",
+  loading_services: "Cargando servicios...",
+  loading_doctor: "Ejecutando brew doctor... (puede tardar un momento)",
+  loading_profiles: "Cargando perfiles...",
+  loading_cleanup: "Analizando paquetes... (verificando uso de disco)",
+  loading_history: "Cargando historial...",
+  loading_security: "Escaneando paquetes en la base de datos de vulnerabilidades OSV...",
+  loading_searching: "Buscando...",
+  loading_package: "Cargando {{name}}...",
+  // ── Confirm dialog ──
+  confirm_yes: "[S]\xED",
+  confirm_no: "[N]o",
+  // ── Error ──
+  error_prefix: "Error: ",
+  // ── Common ──
+  common_andMore: "...y {{count}} m\xE1s",
+  common_exit: "(salida {{code}})",
+  common_yes: "s\xED",
+  common_no: "no",
+  // ── Relative time ──
+  time_justNow: "ahora",
+  time_minutesAgo: "hace {{n}}m",
+  time_hoursAgo: "hace {{n}}h",
+  time_daysAgo: "hace {{n}}d",
+  time_monthsAgo: "hace {{n}}me",
+  // ── Badges ──
+  badge_outdated: "desactualizado",
+  badge_pinned: "fijado",
+  badge_kegOnly: "keg-only",
+  badge_dep: "dep",
+  badge_installed: "instalado",
+  badge_deprecated: "obsoleto",
+  badge_ok: "ok",
+  badge_fail: "fallo",
+  badge_error: "error",
+  // ── Dashboard ──
+  dashboard_overview: "Resumen",
+  dashboard_formulae: "Formulae",
+  dashboard_casks: "Casks",
+  dashboard_outdated: "Desactualizados",
+  dashboard_services: "Servicios",
+  dashboard_systemInfo: "Info del Sistema",
+  dashboard_homebrew: "Homebrew:",
+  dashboard_prefix: "Prefijo:",
+  dashboard_updated: "Actualizado:",
+  dashboard_outdatedPackages: "Paquetes Desactualizados",
+  dashboard_serviceErrors: "Errores de Servicios",
+  // ── Installed ──
+  installed_formulaeCount: "Formulae ({{count}})",
+  installed_casksCount: "Casks ({{count}})",
+  installed_filterDisplay: 'Filtro: "{{query}}" ({{count}} coincidencias)',
+  installed_noPackages: "No se encontraron paquetes",
+  installed_confirmUninstall: "\xBFDesinstalar {{name}}?",
+  // ── Search ──
+  search_placeholder: "Buscar paquetes Homebrew... (enter para buscar)",
+  search_resultsFor: "Resultados para",
+  search_escToClear: "(esc para limpiar)",
+  search_installing: "Instalando paquete...",
+  search_installComplete: "\xA1Instalaci\xF3n completa!",
+  search_confirmInstall: "\xBFInstalar {{name}}?",
+  search_formulaeHeader: "=== Formulae ({{count}})",
+  search_casksHeader: "=== Casks ({{count}})",
+  search_noResults: "Sin resultados",
+  // ── Outdated ──
+  outdated_title: "Paquetes Desactualizados ({{count}})",
+  outdated_upgrading: "Actualizando...",
+  outdated_upgradeComplete: "\xA1Actualizaci\xF3n completa!",
+  outdated_pressRefresh: "(presiona r para refrescar)",
+  outdated_upToDate: "\xA1Todo est\xE1 al d\xEDa!",
+  outdated_confirmAll: "\xBFActualizar los {{count}} paquetes?",
+  outdated_confirmSingle: "\xBFActualizar {{name}}?",
+  outdated_pinned: "[fijado]",
+  // ── Package Info ──
+  pkgInfo_noPackage: "Ning\xFAn paquete seleccionado. Ve a Instalados y presiona Enter en un paquete.",
+  pkgInfo_notFound: "Paquete no encontrado",
+  pkgInfo_installing: "Instalando {{name}}...",
+  pkgInfo_uninstalling: "Desinstalando {{name}}...",
+  pkgInfo_upgrading: "Actualizando {{name}}...",
+  pkgInfo_done: "\xA1Listo!",
+  pkgInfo_confirmInstall: "\xBFinstalar {{name}}?",
+  pkgInfo_confirmUninstall: "\xBFdesinstalar {{name}}?",
+  pkgInfo_confirmUpgrade: "\xBFactualizar {{name}}?",
+  pkgInfo_details: "Detalles",
+  pkgInfo_homepage: "Web:",
+  pkgInfo_license: "Licencia:",
+  pkgInfo_tap: "Tap:",
+  pkgInfo_stable: "Estable:",
+  pkgInfo_installed: "Instalado:",
+  pkgInfo_bottle: "Bottle:",
+  pkgInfo_onRequest: "Por solicitud:",
+  pkgInfo_noDependency: "no (dependencia)",
+  pkgInfo_dependencies: "Dependencias ({{count}})",
+  pkgInfo_caveats: "Advertencias",
+  // ── Services ──
+  services_title: "Servicios Homebrew",
+  services_titleCount: "Servicios Homebrew ({{count}})",
+  services_noServices: "No se encontraron servicios",
+  services_name: "Nombre",
+  services_status: "Estado",
+  services_user: "Usuario",
+  services_processing: "Procesando...",
+  services_confirmStop: "\xBFDetener servicio {{name}}?",
+  services_confirmRestart: "\xBFReiniciar servicio {{name}}?",
+  // ── Doctor ──
+  doctor_title: "Homebrew Doctor",
+  doctor_clean: "Tu sistema est\xE1 listo para brew.",
+  doctor_warningsNotCaptured: "Doctor termin\xF3 con advertencias pero no se capturaron.",
+  // ── Profiles ──
+  profiles_title: "Perfiles de Paquetes ({{count}})",
+  profiles_importTitle: "Importando perfil...",
+  profiles_importComplete: "Importaci\xF3n completa. Presiona cualquier tecla.",
+  profiles_createName: "Crear Perfil \u2014 Nombre:",
+  profiles_namePlaceholder: "ej. trabajo, personal, proyecto-x",
+  profiles_createDesc: 'Crear Perfil "{{name}}" \u2014 Descripci\xF3n:',
+  profiles_descPlaceholder: "Breve descripci\xF3n de esta configuraci\xF3n",
+  profiles_created: "Creado: {{date}}",
+  profiles_formulaeCount: "Formulae ({{count}})",
+  profiles_casksCount: "Casks ({{count}})",
+  profiles_confirmDelete: '\xBFEliminar perfil "{{name}}"?',
+  profiles_noProfiles: "A\xFAn no hay perfiles guardados.",
+  profiles_press: "Presiona",
+  profiles_exportHint: "para exportar tu configuraci\xF3n actual como perfil.",
+  profiles_editName: "Editar Perfil \u2014 Nombre:",
+  profiles_editDesc: 'Editar Perfil "{{name}}" \u2014 Descripci\xF3n:',
+  // ── Smart Cleanup ──
+  cleanup_title: "Limpieza Inteligente",
+  cleanup_cleaning: "Limpiando...",
+  cleanup_complete: "\xA1Limpieza completa! Presiona r para re-analizar.",
+  cleanup_orphans: "Hu\xE9rfanos",
+  cleanup_reclaimable: "Recuperable",
+  cleanup_selected: "Seleccionados",
+  cleanup_confirmUninstall: "\xBFDesinstalar {{count}} paquetes?",
+  cleanup_confirmForce: "Algunos paquetes tienen dependencias. \xBFForzar desinstalaci\xF3n de {{count}} paquetes? (ignora dependencias)",
+  cleanup_depError: "Algunos paquetes no pudieron eliminarse por dependencias.",
+  cleanup_systemClean: "\xA1No se encontraron paquetes hu\xE9rfanos. Tu sistema est\xE1 limpio!",
+  // ── History ──
+  history_title: "Historial de Acciones ({{count}})",
+  history_filterLabel: "filtro: {{filter}}",
+  history_searchPlaceholder: "Buscar paquetes...",
+  history_confirmClear: "\xBFBorrar las {{count}} entradas del historial?",
+  history_noEntries: "Sin entradas en el historial",
+  history_noEntriesFor: 'Sin entradas en el historial para "{{filter}}"',
+  history_all: "(todos)",
+  history_actionInstall: "instalar",
+  history_actionUninstall: "desinstalar",
+  history_actionUpgrade: "actualizar",
+  history_actionUpgradeAll: "actualizar-todo",
+  history_confirmReplay: "\xBFRe-ejecutar: {{action}} {{name}}?",
+  history_replayAll: "\xBFRe-ejecutar: actualizar todos los paquetes?",
+  // ── Security Audit ──
+  security_title: "Auditor\xEDa de Seguridad",
+  security_scanned: "Escaneados",
+  security_vulnerable: "Vulnerables",
+  security_critical: "Cr\xEDticos",
+  security_high: "Altos",
+  security_medium: "Medios",
+  security_noVulns: "\xA1No se encontraron vulnerabilidades conocidas en tus paquetes instalados!",
+  security_fixedIn: "Corregido en: {{version}}",
+  security_confirmUpgrade: "\xBFActualizar {{name}} para corregir vulnerabilidades?",
+  // ── Account ──
+  account_title: "Cuenta y Licencia",
+  account_confirmDeactivate: "\xBFDesactivar tu licencia Pro en esta m\xE1quina?",
+  account_statusLabel: "Estado:",
+  account_pro: "[Pro]",
+  account_free: "[Gratis]",
+  account_expired: "[Expirada]",
+  account_validating: "[Validando...]",
+  account_emailLabel: "Email:",
+  account_nameLabel: "Nombre:",
+  account_planLabel: "Plan:",
+  account_monthlyPrice: "9\u20AC/mes",
+  account_yearlyPrice: "49\u20AC/a\xF1o",
+  account_keyLabel: "Clave:",
+  account_expiresLabel: "Expira:",
+  account_activatedLabel: "Activado:",
+  account_upgradeTitle: "Actualiza a Brew-TUI Pro",
+  account_unlockDesc: "Desbloquea Perfiles, Limpieza Inteligente, Historial, Auditor\xEDa de Seguridad y BrewBar (barra de men\xFA macOS).",
+  account_pricing: "9\u20AC/mes o 49\u20AC/a\xF1o",
+  account_runActivate: "Ejecuta:",
+  account_activateCmd: "brew-tui activate <clave>",
+  account_licenseExpired: "Tu licencia ha expirado. Renueva para seguir usando las funciones Pro.",
+  account_deactivating: "Desactivando...",
+  // ── Upgrade Prompt ──
+  upgrade_proFeature: "{{title}} \u2014 Funci\xF3n Pro",
+  upgrade_profiles: "Perfiles de Paquetes",
+  upgrade_profilesDesc: "Exporta e importa tu configuraci\xF3n de Homebrew entre m\xE1quinas. Guarda perfiles con nombre para trabajo, personal o proyectos espec\xEDficos.",
+  upgrade_cleanup: "Limpieza Inteligente",
+  upgrade_cleanupDesc: "Encuentra paquetes hu\xE9rfanos, analiza uso de disco por paquete y recupera espacio con limpieza inteligente de un clic.",
+  upgrade_history: "Historial de Acciones",
+  upgrade_historyDesc: "Rastrea cada instalaci\xF3n, desinstalaci\xF3n y actualizaci\xF3n con marcas de tiempo. Busca y filtra tu historial de gesti\xF3n de paquetes.",
+  upgrade_security: "Auditor\xEDa de Seguridad",
+  upgrade_securityDesc: "Escanea paquetes instalados contra vulnerabilidades conocidas (CVEs). Ve niveles de severidad, versiones afectadas y correcciones disponibles.",
+  upgrade_pricing: "9\u20AC/mes o 49\u20AC/a\xF1o",
+  upgrade_activateWith: "Activa con:",
+  upgrade_activateCmd: "brew-tui activate <tu-clave-de-licencia>",
+  upgrade_proLabel: "Brew-TUI Pro \u2014 9\u20AC/mes o 49\u20AC/a\xF1o \u2014 Incluye BrewBar para macOS",
+  // ── Progress Log ──
+  progress_noOutput: "Sin salida a\xFAn",
+  // ── Search Input ──
+  searchInput_placeholder: "Escriba para filtrar...",
+  // ── Profile Manager ──
+  profileMgr_tapping: "A\xF1adiendo tap {{name}}...",
+  profileMgr_installing: "Instalando {{name}}...",
+  profileMgr_installingCask: "Instalando cask {{name}}...",
+  profileMgr_importDone: "\xA1Listo! {{count}} paquetes instalados.",
+  // ── CLI ──
+  cli_usageActivate: "Uso: brew-tui activate <clave-de-licencia>",
+  cli_activated: "\u2714 Pro activado para {{email}}",
+  cli_plan: "  Plan: {{plan}}",
+  cli_expires: "  Expira: {{date}}",
+  cli_activationFailed: "\u2718 Activaci\xF3n fallida: {{error}}",
+  cli_noLicense: "No se encontr\xF3 licencia activa.",
+  cli_deactivated: "\u2714 Licencia desactivada.",
+  cli_planFree: "Plan: Gratis",
+  cli_planPro: "Plan: Pro",
+  cli_confirmDeactivate: "\xBFDesactivar tu licencia Pro en esta m\xE1quina? (s/N): ",
+  cli_deactivateCancelled: "Desactivaci\xF3n cancelada.",
+  cli_upgradeHint: "Ejecuta `brew-tui activate <clave>` para actualizar a Pro.",
+  cli_email: "Email: {{email}}",
+  cli_status: "Estado: {{status}}",
+  cli_rateLimited: "Demasiados intentos de activaci\xF3n. Int\xE9ntalo en {{minutes}} minutos.",
+  cli_cooldown: "Por favor espera antes de intentar de nuevo.",
+  cli_brewbarInstalling: "Descargando BrewBar...",
+  cli_brewbarInstalled: "\u2714 BrewBar instalado en /Applications/BrewBar.app",
+  cli_brewbarAlreadyInstalled: "BrewBar ya est\xE1 instalado. Usa --force para reinstalar.",
+  cli_brewbarUninstalled: "\u2714 BrewBar eliminado de /Applications.",
+  cli_brewbarNotInstalled: "BrewBar no est\xE1 instalado.",
+  cli_brewbarProRequired: "\u2718 BrewBar requiere una licencia Pro.\n  Ejecuta: brew-tui activate <clave>",
+  cli_brewbarMacOnly: "\u2718 BrewBar solo est\xE1 disponible en macOS.",
+  cli_brewbarDownloadFailed: "\u2718 Error al descargar BrewBar: {{error}}",
+  // ── License degradation (Layer 15) ──
+  license_offlineWarning: "Tu licencia no se ha validado en {{days}} d\xEDas. Por favor con\xE9ctate a internet.",
+  // ── Plurals ──
+  plural_vulns_one: "({{count}} vuln)",
+  plural_vulns_other: "({{count}} vulns)",
+  plural_warnings_one: "{{count}} advertencia",
+  plural_warnings_other: "{{count}} advertencias",
+  // ── Scroll indicators ──
+  scroll_moreAbove: "\u2191 {{count}} m\xE1s",
+  scroll_moreBelow: "\u2193 {{count}} m\xE1s"
+};
+var es_default = es;
+
+// src/i18n/index.ts
+var locales = { en: en_default, es: es_default };
+function isLocale(s) {
+  return s === "en" || s === "es";
+}
+function detectLocale() {
+  const flag = process.argv.find((a) => a.startsWith("--lang="));
+  if (flag) {
+    const code = flag.split("=")[1];
+    if (code && isLocale(code)) return code;
+  }
+  const env = process.env.LANG ?? process.env.LC_ALL ?? process.env.LC_MESSAGES ?? "";
+  const prefix = env.split(/[_.]/)[0] ?? "";
+  if (isLocale(prefix)) return prefix;
+  return "en";
+}
+var useLocaleStore = create((set) => ({
+  locale: detectLocale(),
+  setLocale: (locale) => set({ locale })
+}));
+function t(key, values) {
+  const locale = useLocaleStore.getState().locale;
+  let text = locales[locale][key] ?? locales["en"][key] ?? key;
+  if (values) {
+    for (const [k, v] of Object.entries(values)) {
+      text = text.replaceAll(`{{${k}}}`, String(v));
+    }
+  }
+  return text;
+}
+function tp(baseKey, count, values) {
+  const suffix = count === 1 ? "_one" : "_other";
+  return t(`${baseKey}${suffix}`, { count, ...values });
+}
+
+// src/lib/data-dir.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir } from "fs/promises";
+var DATA_DIR = join(homedir(), ".brew-tui");
+var PROFILES_DIR = join(DATA_DIR, "profiles");
+var LICENSE_PATH = join(DATA_DIR, "license.json");
+var HISTORY_PATH = join(DATA_DIR, "history.json");
+async function ensureDataDirs() {
+  await mkdir(DATA_DIR, { recursive: true });
+  await mkdir(PROFILES_DIR, { recursive: true });
+}
+
+// src/lib/license/license-manager.ts
+import { readFile, writeFile, rm } from "fs/promises";
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+
+// src/lib/license/polar-api.ts
+import { hostname } from "os";
+var BASE_URL = "https://api.polar.sh/v1/customer-portal/license-keys";
+var POLAR_ORGANIZATION_ID = "b8f245c0-d116-4457-92fb-1bda47139f82";
+function validateApiUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:") {
+    throw new Error("HTTPS required for license API");
+  }
+  if (!parsed.hostname.endsWith("polar.sh")) {
+    throw new Error("Invalid API host");
+  }
+}
+async function post(endpoint, body, expectEmpty = false) {
+  const url = `${BASE_URL}/${endpoint}`;
+  validateApiUrl(url);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    let message = `Request failed with status ${res.status}`;
+    try {
+      const errBody = await res.json();
+      if (typeof errBody.detail === "string") message = errBody.detail;
+      else if (typeof errBody.error === "string") message = errBody.error;
+      else if (typeof errBody.message === "string") message = errBody.message;
+    } catch {
+    }
+    throw new Error(message);
+  }
+  if (expectEmpty || res.status === 204) return void 0;
+  return res.json();
+}
+async function activateLicense(key) {
+  const activation = await post("activate", {
+    key,
+    organization_id: POLAR_ORGANIZATION_ID,
+    label: hostname()
+  });
+  let customerEmail = "";
+  let customerName = "";
+  try {
+    const validated = await post("validate", {
+      key,
+      organization_id: POLAR_ORGANIZATION_ID,
+      activation_id: activation.id
+    });
+    customerEmail = validated.customer?.email ?? "";
+    customerName = validated.customer?.name ?? "";
+  } catch {
+  }
+  return {
+    activated: true,
+    error: null,
+    instance: { id: activation.id },
+    license_key: {
+      id: 0,
+      status: activation.license_key.status,
+      key,
+      activation_limit: 0,
+      activations_count: 0,
+      expires_at: activation.license_key.expires_at
+    },
+    meta: { customer_email: customerEmail, customer_name: customerName }
+  };
+}
+async function validateLicense(key, instanceId) {
+  const res = await post("validate", {
+    key,
+    organization_id: POLAR_ORGANIZATION_ID,
+    activation_id: instanceId
+  });
+  const notExpired = res.expires_at === null || new Date(res.expires_at) > /* @__PURE__ */ new Date();
+  const valid = res.status === "granted" && notExpired;
+  return {
+    valid,
+    error: valid ? null : `License ${res.status}`,
+    license_key: {
+      id: 0,
+      status: res.status,
+      key,
+      expires_at: res.expires_at
+    },
+    instance: { id: instanceId }
+  };
+}
+async function deactivateLicense(key, instanceId) {
+  await post(
+    "deactivate",
+    { key, organization_id: POLAR_ORGANIZATION_ID, activation_id: instanceId },
+    true
+  );
+}
+
+// src/lib/license/license-manager.ts
+var REVALIDATION_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var GRACE_PERIOD_MS = 7 * 24 * 60 * 60 * 1e3;
+var ACTIVATION_COOLDOWN_MS = 3e4;
+var MAX_ATTEMPTS = 5;
+var LOCKOUT_MS = 15 * 60 * 1e3;
+var tracker = {
+  attempts: 0,
+  lastAttempt: 0,
+  lockedUntil: 0
+};
+function checkRateLimit() {
+  const now = Date.now();
+  if (now < tracker.lockedUntil) {
+    const remaining = Math.ceil((tracker.lockedUntil - now) / 6e4);
+    throw new Error(t("cli_rateLimited", { minutes: remaining }));
+  }
+  if (now - tracker.lastAttempt < ACTIVATION_COOLDOWN_MS) {
+    throw new Error(t("cli_cooldown"));
+  }
+}
+function recordAttempt(success) {
+  const now = Date.now();
+  tracker.lastAttempt = now;
+  if (success) {
+    tracker.attempts = 0;
+    return;
+  }
+  tracker.attempts++;
+  if (tracker.attempts >= MAX_ATTEMPTS) {
+    tracker.lockedUntil = now + LOCKOUT_MS;
+    tracker.attempts = 0;
+  }
+}
+var ENCRYPTION_SECRET = "brew-tui-license-aes256gcm-v1";
+var SCRYPT_SALT = "brew-tui-salt-v1";
+var _derivedKey = scryptSync(ENCRYPTION_SECRET, SCRYPT_SALT, 32);
+function deriveEncryptionKey() {
+  return _derivedKey;
+}
+function encryptLicenseData(data) {
+  const key = deriveEncryptionKey();
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const plaintext = JSON.stringify(data);
+  const ciphertext = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    encrypted: ciphertext.toString("base64"),
+    iv: iv.toString("base64"),
+    tag: tag.toString("base64")
+  };
+}
+function decryptLicenseData(encrypted, iv, tag) {
+  const key = deriveEncryptionKey();
+  const decipher = createDecipheriv(
+    "aes-256-gcm",
+    key,
+    Buffer.from(iv, "base64")
+  );
+  decipher.setAuthTag(Buffer.from(tag, "base64"));
+  const plaintext = Buffer.concat([
+    decipher.update(Buffer.from(encrypted, "base64")),
+    decipher.final()
+  ]);
+  return JSON.parse(plaintext.toString("utf-8"));
+}
+async function loadLicense() {
+  try {
+    const raw = await readFile(LICENSE_PATH, "utf-8");
+    const file = JSON.parse(raw);
+    if (file.encrypted && file.iv && file.tag) {
+      const data = decryptLicenseData(file.encrypted, file.iv, file.tag);
+      return data;
+    }
+    if (file.license) {
+      const data = file.license;
+      await saveLicense(data);
+      return data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveLicense(data) {
+  await ensureDataDirs();
+  const { encrypted, iv, tag } = encryptLicenseData(data);
+  const file = { version: 1, encrypted, iv, tag };
+  await writeFile(LICENSE_PATH, JSON.stringify(file, null, 2), { encoding: "utf-8", mode: 384 });
+}
+async function clearLicense() {
+  try {
+    await rm(LICENSE_PATH);
+  } catch {
+  }
+}
+function isExpired(license) {
+  if (!license.expiresAt) return false;
+  return new Date(license.expiresAt).getTime() < Date.now();
+}
+function needsRevalidation(license) {
+  const lastValidated = new Date(license.lastValidatedAt).getTime();
+  if (isNaN(lastValidated)) return true;
+  return Date.now() - lastValidated > REVALIDATION_INTERVAL_MS;
+}
+function isWithinGracePeriod(license) {
+  const lastValidated = new Date(license.lastValidatedAt).getTime();
+  if (isNaN(lastValidated)) return false;
+  return Date.now() - lastValidated < GRACE_PERIOD_MS;
+}
+function getDegradationLevel(license) {
+  const lastValidated = new Date(license.lastValidatedAt).getTime();
+  if (isNaN(lastValidated)) return "expired";
+  const elapsed = Date.now() - lastValidated;
+  if (elapsed < 0) return "none";
+  const days = elapsed / (24 * 60 * 60 * 1e3);
+  if (days <= 7) return "none";
+  if (days <= 14) return "warning";
+  if (days <= 30) return "limited";
+  return "expired";
+}
+function validateLicenseKey(key) {
+  if (key.length < 10 || key.length > 100) {
+    throw new Error("Invalid license key format");
+  }
+  if (!/^[\w-]+$/.test(key)) {
+    throw new Error("Invalid license key format");
+  }
+}
+async function activate(key) {
+  validateLicenseKey(key);
+  checkRateLimit();
+  let success = false;
+  try {
+    const res = await activateLicense(key);
+    if (!res.activated) {
+      throw new Error(res.error ?? "Activation failed");
+    }
+    const license = {
+      key,
+      instanceId: res.instance.id,
+      status: "active",
+      customerEmail: res.meta.customer_email,
+      customerName: res.meta.customer_name,
+      plan: "pro",
+      activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: res.license_key.expires_at,
+      lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await saveLicense(license);
+    success = true;
+    return license;
+  } finally {
+    recordAttempt(success);
+  }
+}
+async function revalidate(license) {
+  try {
+    const res = await validateLicense(license.key, license.instanceId);
+    if (res.valid) {
+      const updated = {
+        ...license,
+        lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "active",
+        expiresAt: res.license_key.expires_at
+      };
+      await saveLicense(updated);
+      return true;
+    }
+    await saveLicense({ ...license, status: "expired" });
+    return false;
+  } catch {
+    return isWithinGracePeriod(license);
+  }
+}
+async function deactivate(license) {
+  try {
+    await deactivateLicense(license.key, license.instanceId);
+  } catch {
+  }
+  await clearLicense();
+}
+
+// src/stores/license-store.ts
+import { create as create2 } from "zustand";
+var REVALIDATION_CHECK_MS = 60 * 60 * 1e3;
+var _revalidating = false;
+var useLicenseStore = create2((set, get) => ({
+  status: "free",
+  license: null,
+  error: null,
+  degradation: "none",
+  initialize: async () => {
+    await ensureDataDirs();
+    const license = await loadLicense();
+    if (!license) {
+      set({ status: "free", license: null, degradation: "none" });
+      return;
+    }
+    if (isExpired(license)) {
+      set({ status: "expired", license, degradation: "expired" });
+      return;
+    }
+    const level = getDegradationLevel(license);
+    if (level === "expired") {
+      set({ status: "expired", license, degradation: "expired" });
+      return;
+    }
+    set({ status: "pro", license, degradation: level });
+    if (needsRevalidation(license) && !_revalidating) {
+      _revalidating = true;
+      try {
+        const valid = await revalidate(license);
+        if (!valid) {
+          set({ status: "expired", license: { ...license, status: "expired" } });
+        } else {
+          const updated = await loadLicense();
+          if (updated) set({ license: updated });
+        }
+      } finally {
+        _revalidating = false;
+      }
+    }
+    setInterval(async () => {
+      const current = get().license;
+      if (!current || get().status !== "pro") return;
+      if (!needsRevalidation(current)) return;
+      if (_revalidating) return;
+      _revalidating = true;
+      try {
+        const valid = await revalidate(current);
+        if (!valid) {
+          set({ status: "expired", license: { ...current, status: "expired" } });
+        } else {
+          const updated = await loadLicense();
+          if (updated) set({ license: updated });
+        }
+      } finally {
+        _revalidating = false;
+      }
+    }, REVALIDATION_CHECK_MS).unref();
+  },
+  activate: async (key) => {
+    set({ error: null });
+    try {
+      const license = await activate(key);
+      set({ status: "pro", license });
+      return true;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      set({ error: msg });
+      return false;
+    }
+  },
+  deactivate: async () => {
+    const { license } = get();
+    if (license) {
+      await deactivate(license);
+    }
+    set({ status: "free", license: null, error: null });
+  },
+  isPro: () => get().status === "pro"
+}));
+
+// src/lib/license/anti-debug.ts
+import inspector from "inspector";
+function isDebuggerAttached() {
+  if (process.env.VITEST || process.env.CI) return false;
+  if (inspector.url()) return true;
+  if (process.execArgv.some((a) => a.includes("--inspect") || a.includes("--debug"))) return true;
+  if (process.env.NODE_OPTIONS?.includes("--inspect")) return true;
+  return false;
+}
+
+// src/lib/license/anti-tamper.ts
+var _originalIsPro = useLicenseStore.getState().isPro;
+var _originalGetState = useLicenseStore.getState;
+function verifyStoreIntegrity() {
+  const state = useLicenseStore.getState();
+  if (state.isPro !== _originalIsPro) return false;
+  if (useLicenseStore.getState !== _originalGetState) return false;
+  if (state.status === "free" && state.isPro()) return false;
+  return true;
+}
+
+// src/lib/license/canary.ts
+var _canaryTripped = false;
+function isProUnlocked() {
+  return false;
+}
+function hasProAccess() {
+  return false;
+}
+function isLicenseValid() {
+  return false;
+}
+function checkCanaries() {
+  if (isProUnlocked()) {
+    _canaryTripped = true;
+    return false;
+  }
+  if (hasProAccess()) {
+    _canaryTripped = true;
+    return false;
+  }
+  if (isLicenseValid()) {
+    _canaryTripped = true;
+    return false;
+  }
+  return !_canaryTripped;
+}
+
+// src/lib/license/integrity.ts
+import { readFileSync } from "fs";
+import { createHash } from "crypto";
+import { fileURLToPath } from "url";
+var _baselineHash = null;
+function _captureBaseline() {
+  try {
+    const bundlePath = fileURLToPath(import.meta.url);
+    const content = readFileSync(bundlePath, "utf-8");
+    return createHash("sha256").update(content).digest("hex");
+  } catch {
+    return null;
+  }
+}
+_baselineHash = _captureBaseline();
+function checkBundleIntegrity() {
+  if (_baselineHash === null) {
+    return true;
+  }
+  try {
+    const bundlePath = fileURLToPath(import.meta.url);
+    const content = readFileSync(bundlePath, "utf-8");
+    const current = createHash("sha256").update(content).digest("hex");
+    return current === _baselineHash;
+  } catch {
+    return true;
+  }
+}
+
+// src/lib/license/pro-guard.ts
+var _S = String.fromCharCode(115, 116, 97, 116, 117, 115);
+var _P = String.fromCharCode(112, 114, 111);
+function _verify() {
+  const state = useLicenseStore.getState();
+  return state[_S] === _P;
+}
+function verifyPro() {
+  if (isDebuggerAttached()) return false;
+  if (!checkBundleIntegrity()) return false;
+  if (!verifyStoreIntegrity()) return false;
+  if (!checkCanaries()) return false;
+  const directCheck = useLicenseStore.getState().status === "pro";
+  const indirectCheck = _verify();
+  if (!directCheck || !indirectCheck) return false;
+  const license = useLicenseStore.getState().license;
+  if (license) {
+    const level = getDegradationLevel(license);
+    if (level === "expired" || level === "limited") return false;
+  }
+  return true;
+}
+function requirePro() {
+  if (!verifyPro()) {
+    throw new Error("Pro license required");
+  }
+}
+
+export {
+  useLocaleStore,
+  t,
+  tp,
+  PROFILES_DIR,
+  HISTORY_PATH,
+  ensureDataDirs,
+  loadLicense,
+  activate,
+  deactivate,
+  useLicenseStore,
+  verifyPro,
+  requirePro
+};
+//# sourceMappingURL=chunk-P6PTN4HR.js.map