@plop-next/i18n 0.1.0

package/dist/index.js

@@ -0,0 +1,1468 @@
+// src/PlopNextI18n.ts
+import {
+  createConfirmHandler,
+  createSelectHandler,
+  createCheckboxHandler,
+  createSearchHandler,
+  createEditorHandler,
+  createPasswordHandler
+} from "@plop-next/core";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, extname, isAbsolute, resolve } from "path";
+import { createRequire } from "module";
+import { createLocalizedPrompts } from "@inquirer/i18n";
+
+// src/locales/en.ts
+import { CORE_DEFAULT_TEXTS } from "@plop-next/core";
+var EN_MESSAGES = CORE_DEFAULT_TEXTS;
+var BASE_LOCALE = "en";
+var DEFAULT_TEXTS_EN = CORE_DEFAULT_TEXTS;
+
+// src/locales/es.ts
+var ES_MESSAGES = {
+  cli: {
+    title: "Bienvenido a plop-next! \u{1F680}",
+    welcomeMessage: null,
+    selectGenerator: "Seleccione un generador",
+    noGenerators: "No hay generadores registrados. Agreguelos en su plopfile.",
+    generatorNotFound: (name) => `Generador "${name}" no encontrado.`,
+    aborted: "Cancelado.",
+    done: "Listo!",
+    promptCancelled: "Consola cerrada por el usuario."
+  },
+  inquirer: {
+    confirm: {
+      yesLabel: "S\xED",
+      noLabel: "No",
+      hintYes: "S/n",
+      hintNo: "s/N"
+    },
+    select: {
+      helpNavigate: "navegar",
+      helpSelect: "seleccionar"
+    },
+    checkbox: {
+      helpNavigate: "navegar",
+      helpSelect: "seleccionar",
+      helpSubmit: "enviar",
+      helpAll: "todos",
+      helpInvert: "invertir"
+    },
+    search: {
+      helpNavigate: "navegar",
+      helpSelect: "seleccionar"
+    },
+    editor: {
+      waitingMessage: (enterKey) => `Presione ${enterKey} para lanzar su editor preferido.`
+    },
+    password: {
+      maskedText: "[entrada oculta]"
+    }
+  },
+  actions: {
+    add: {
+      creating: (path) => `Creando ${path}`,
+      created: (path) => `\u2714 Creado ${path}`,
+      alreadyExists: (path) => `El archivo ya existe: ${path}`
+    },
+    modify: {
+      modifying: (path) => `Modificando ${path}`,
+      modified: (path) => `\u2714 Modificado ${path}`,
+      notFound: (path) => `Archivo no encontrado: ${path}`,
+      patternNotFound: (path) => `Patron no encontrado en: ${path}`
+    },
+    append: {
+      appending: (path) => `Anadiendo en ${path}`,
+      appended: (path) => `\u2714 Anadido en ${path}`
+    }
+  },
+  errors: {
+    unknownAction: (type) => `Tipo de accion desconocido: "${type}"`,
+    plopfileNotFound: "No se pudo encontrar un plopfile (plopfile.js o plopfile.ts).",
+    plopfileLoadFailed: (err) => `Error al cargar el plopfile: ${err}`,
+    generatorNotFound: (name) => `Generador "${name}" no encontrado.`,
+    noGenerators: "No hay generadores registrados. Agreguelos en su plopfile.",
+    invalidPrompt: (name, reason) => `Prompt invalido "${name}": ${reason}`,
+    bypassParse: (promptName, promptType, value, detail) => `No se puede asignar el valor de bypass "${value}" al prompt ${promptType} "${promptName}"${detail ? `: ${detail}` : ""}`,
+    plopfileLoad: (path) => `Error al cargar el plopfile: ${path}`,
+    plopfileExport: "El plopfile debe exportar una funcion por defecto.",
+    userCancelled: "Prompt cancelado por el usuario.",
+    plopfileNotFoundWarning: "No se encontro ningun plopfile. Cree un plopfile.js en su proyecto.",
+    forcedLangI18nMissing: (locale) => `La locale forzada "${locale}" se ignora porque @plop-next/i18n no esta instalado. Se usa ingles.`,
+    forcedLangUnavailable: (locale) => `La locale forzada "${locale}" no esta disponible. Se usa ingles.`
+  },
+  /**
+   * CLI `--help` display texts — Spanish.
+   * Read-only: cannot be overridden via `registerLocale` / `registerTexts`.
+   */
+  help: {
+    usage: "Uso:",
+    usage1: "Elegir de la lista de generadores disponibles",
+    usage2: "Ejecutar un generador registrado bajo este nombre",
+    usage3: "Ejecutar el generador con datos de entrada para omitir prompts",
+    options: "Opciones:",
+    optHelp: "Mostrar esta ayuda",
+    optShowTypeNames: "Mostrar nombres de tipo en lugar de abreviaciones",
+    optInitTitle: "Inicializaci\xF3n del Plopfile",
+    optGenerateTitle: "Generar archivos de Locale, Texts, Theme",
+    optOthersTitle: "Otras opciones",
+    optInit: "Generar un plopfile.ts base",
+    optInitJs: "Generar un plopfile.js base",
+    optInitTs: "Generar un plopfile.ts base",
+    optDemo: "Generar un generador de ejemplo en el plopfile",
+    optI18n: "Inicializar el plopfile con soporte i18n",
+    optGenerate: "Generar un modelo: locale | textos | tema",
+    optPath: "Directorio de salida base para los archivos de modelo generados",
+    optExtension: "Extensi\xF3n de archivo generada: ts | js | json",
+    optIncludeCustomTexts: "Para la generaci\xF3n de locale, incluir las claves traducibles del plopfile",
+    optVersion: "Mostrar la version actual",
+    optForce: "Ejecutar el generador en modo forzado",
+    optLang: "Forzar la locale de visualizacion (ej. en, es, fr)",
+    danger: "el peligro espera a quienes se aventuran bajo esta linea",
+    lowPlopfile: "Ruta al plopfile",
+    lowCwd: "Directorio base para calcular rutas relativas durante la busqueda del plopfile",
+    lowPreload: "Cadena o arreglo de modulos para cargar antes de plop-next",
+    lowDest: "Escribir salida en esta carpeta en lugar de la carpeta padre del plopfile",
+    lowNoProgress: "Desactivar el spinner de progreso",
+    examples: "Ejemplos:"
+  }
+};
+
+// src/locales/fr.ts
+var FR_MESSAGES = {
+  cli: {
+    title: "Bienvenue dans plop-next ! \u{1F680}",
+    welcomeMessage: null,
+    selectGenerator: "Veuillez choisir un g\xE9n\xE9rateur",
+    noGenerators: "Aucun g\xE9n\xE9rateur enregistr\xE9. Ajoutez-en dans votre plopfile.",
+    generatorNotFound: (name) => `G\xE9n\xE9rateur "${name}" introuvable.`,
+    aborted: "Annul\xE9.",
+    done: "Termin\xE9 !",
+    promptCancelled: "Console ferm\xE9e par l'utilisateur."
+  },
+  inquirer: {
+    confirm: {
+      yesLabel: "Oui",
+      noLabel: "Non",
+      hintYes: "O/n",
+      hintNo: "o/N"
+    },
+    select: {
+      helpNavigate: "naviguer",
+      helpSelect: "s\xE9lectionner"
+    },
+    checkbox: {
+      helpNavigate: "naviguer",
+      helpSelect: "s\xE9lectionner",
+      helpSubmit: "soumettre",
+      helpAll: "tout",
+      helpInvert: "inverser"
+    },
+    search: {
+      helpNavigate: "naviguer",
+      helpSelect: "s\xE9lectionner"
+    },
+    editor: {
+      waitingMessage: (enterKey) => `Appuyez sur ${enterKey} pour lancer votre \xE9diteur pr\xE9f\xE9r\xE9.`
+    },
+    password: {
+      maskedText: "[saisie masqu\xE9e]"
+    }
+  },
+  actions: {
+    add: {
+      creating: (path) => `Cr\xE9ation de ${path}`,
+      created: (path) => `\u2714 Cr\xE9\xE9 ${path}`,
+      alreadyExists: (path) => `Le fichier existe d\xE9j\xE0 : ${path}`
+    },
+    modify: {
+      modifying: (path) => `Modification de ${path}`,
+      modified: (path) => `\u2714 Modifi\xE9 ${path}`,
+      notFound: (path) => `Fichier introuvable : ${path}`,
+      patternNotFound: (path) => `Motif introuvable dans : ${path}`
+    },
+    append: {
+      appending: (path) => `Ajout dans ${path}`,
+      appended: (path) => `\u2714 Ajout\xE9 dans ${path}`
+    }
+  },
+  errors: {
+    unknownAction: (type) => `Type d'action inconnu : "${type}"`,
+    plopfileNotFound: "Impossible de trouver un plopfile (plopfile.js ou plopfile.ts).",
+    plopfileLoadFailed: (err) => `\xC9chec du chargement du plopfile : ${err}`,
+    generatorNotFound: (name) => `G\xE9n\xE9rateur "${name}" introuvable.`,
+    noGenerators: "Aucun g\xE9n\xE9rateur enregistr\xE9. Ajoutez-en dans votre plopfile.",
+    invalidPrompt: (name, reason) => `Prompt invalide "${name}" : ${reason}`,
+    bypassParse: (promptName, promptType, value, detail) => `Impossible d'assigner la valeur de bypass "${value}" au prompt ${promptType} "${promptName}"${detail ? `: ${detail}` : ""}`,
+    plopfileLoad: (path) => `\xC9chec du chargement du plopfile : ${path}`,
+    plopfileExport: "Le plopfile doit exporter une fonction par d\xE9faut.",
+    userCancelled: "Prompt annul\xE9 par l'utilisateur.",
+    plopfileNotFoundWarning: "Aucun plopfile trouv\xE9. Cr\xE9ez un plopfile.js dans votre projet.",
+    forcedLangI18nMissing: (locale) => `La locale forc\xE9e "${locale}" est ignor\xE9e car @plop-next/i18n n'est pas install\xE9. Repli sur l'anglais.`,
+    forcedLangUnavailable: (locale) => `La locale forc\xE9e "${locale}" n'est pas disponible. Repli sur l'anglais.`
+  },
+  /**
+   * CLI `--help` display texts — French.
+   * Read-only: cannot be overridden via `registerLocale` / `registerTexts`.
+   */
+  help: {
+    usage: "Utilisation :",
+    usage1: "Choisir dans la liste des g\xE9n\xE9rateurs disponibles",
+    usage2: "Executer un g\xE9n\xE9rateur enregistre sous ce nom",
+    usage3: "Executer le g\xE9n\xE9rateur avec des donnees d'entree pour passer les prompts",
+    options: "Options :",
+    optHelp: "Afficher cette aide",
+    optShowTypeNames: "Afficher les noms de type au lieu des abr\xE9viations",
+    optInitTitle: "Initialisation du Plopfile",
+    optGenerateTitle: "G\xE9n\xE9rer des fichiers Locale, Texts, Theme",
+    optOthersTitle: "Autres options",
+    optInit: "G\xE9n\xE9rer un plopfile.ts de base",
+    optInitJs: "G\xE9n\xE9rer un plopfile.js de base",
+    optInitTs: "G\xE9n\xE9rer un plopfile.ts de base",
+    optDemo: "G\xE9n\xE9rer un g\xE9n\xE9rateur de demo dans le plopfile",
+    optI18n: "Initialiser le plopfile avec le support i18n",
+    optGenerate: "G\xE9n\xE9rer un mod\xE8le : locale | textes | th\xE8me",
+    optPath: "R\xE9pertoire de sortie de base pour les fichiers de mod\xE8le g\xE9n\xE9r\xE9s",
+    optExtension: "Extension de fichier g\xE9n\xE9r\xE9e : ts | js | json",
+    optIncludeCustomTexts: "Pour la g\xE9n\xE9ration de locale, inclure les cl\xE9s traduisibles du plopfile",
+    optVersion: "Afficher la version courante",
+    optForce: "Executer le g\xE9n\xE9rateur en mode force",
+    optLang: "Forcer la locale d'affichage (ex. en, fr)",
+    danger: "le danger attend ceux qui s'aventurent sous la ligne",
+    lowPlopfile: "Chemin vers le plopfile",
+    lowCwd: "Repertoire de base pour calculer les chemins relatifs pendant la recherche du plopfile",
+    lowPreload: "Chaine ou tableau de modules a charger avant plop-next",
+    lowDest: "\xC9crire la sortie dans ce dossier au lieu du dossier parent du plopfile",
+    lowNoProgress: "D\xE9sactiver le spinner de progression",
+    examples: "Exemples :"
+  }
+};
+
+// src/locales/pt.ts
+var PT_MESSAGES = {
+  cli: {
+    title: "Bem-vindo ao plop-next! \u{1F680}",
+    welcomeMessage: null,
+    selectGenerator: "Selecione um gerador",
+    noGenerators: "Nenhum gerador registrado. Adicione-os no seu plopfile.",
+    generatorNotFound: (name) => `Gerador "${name}" nao encontrado.`,
+    aborted: "Cancelado.",
+    done: "Concluido!",
+    promptCancelled: "Console fechado pelo usuario."
+  },
+  inquirer: {
+    confirm: {
+      yesLabel: "Sim",
+      noLabel: "N\xE3o",
+      hintYes: "S/n",
+      hintNo: "s/N"
+    },
+    select: {
+      helpNavigate: "navegar",
+      helpSelect: "selecionar"
+    },
+    checkbox: {
+      helpNavigate: "navegar",
+      helpSelect: "selecionar",
+      helpSubmit: "enviar",
+      helpAll: "todos",
+      helpInvert: "inverter"
+    },
+    search: {
+      helpNavigate: "navegar",
+      helpSelect: "selecionar"
+    },
+    editor: {
+      waitingMessage: (enterKey) => `Pressione ${enterKey} para abrir seu editor preferido.`
+    },
+    password: {
+      maskedText: "[entrada mascarada]"
+    }
+  },
+  actions: {
+    add: {
+      creating: (path) => `Criando ${path}`,
+      created: (path) => `\u2714 Criado ${path}`,
+      alreadyExists: (path) => `O arquivo ja existe: ${path}`
+    },
+    modify: {
+      modifying: (path) => `Modificando ${path}`,
+      modified: (path) => `\u2714 Modificado ${path}`,
+      notFound: (path) => `Arquivo nao encontrado: ${path}`,
+      patternNotFound: (path) => `Padrao nao encontrado em: ${path}`
+    },
+    append: {
+      appending: (path) => `Anexando em ${path}`,
+      appended: (path) => `\u2714 Anexado em ${path}`
+    }
+  },
+  errors: {
+    unknownAction: (type) => `Tipo de acao desconhecido: "${type}"`,
+    plopfileNotFound: "Nao foi possivel encontrar um plopfile (plopfile.js ou plopfile.ts).",
+    plopfileLoadFailed: (err) => `Falha ao carregar o plopfile: ${err}`,
+    generatorNotFound: (name) => `Gerador "${name}" nao encontrado.`,
+    noGenerators: "Nenhum gerador registrado. Adicione-os no seu plopfile.",
+    invalidPrompt: (name, reason) => `Prompt invalido "${name}": ${reason}`,
+    bypassParse: (promptName, promptType, value, detail) => `Nao e possivel atribuir o valor de bypass "${value}" ao prompt ${promptType} "${promptName}"${detail ? `: ${detail}` : ""}`,
+    plopfileLoad: (path) => `Falha ao carregar o plopfile: ${path}`,
+    plopfileExport: "O plopfile deve exportar uma funcao padrao.",
+    userCancelled: "Prompt cancelado pelo usuario.",
+    plopfileNotFoundWarning: "Nenhum plopfile encontrado. Crie um plopfile.js no seu projeto.",
+    forcedLangI18nMissing: (locale) => `A locale forcada "${locale}" foi ignorada porque @plop-next/i18n nao esta instalado. Usando ingles.`,
+    forcedLangUnavailable: (locale) => `A locale forcada "${locale}" nao esta disponivel. Usando ingles.`
+  },
+  /**
+   * CLI `--help` display texts — Portuguese.
+   * Read-only: cannot be overridden via `registerLocale` / `registerTexts`.
+   */
+  help: {
+    usage: "Uso:",
+    usage1: "Escolher na lista de geradores disponiveis",
+    usage2: "Executar um gerador registrado com este nome",
+    usage3: "Executar o gerador com dados de entrada para ignorar prompts",
+    options: "Opcoes:",
+    optHelp: "Mostrar esta ajuda",
+    optShowTypeNames: "Mostrar nomes de tipo em vez de abreviacoes",
+    optInitTitle: "Inicializa\xE7\xE3o do Plopfile",
+    optGenerateTitle: "Gerar arquivos de Locale, Texts, Theme",
+    optOthersTitle: "Outras op\xE7\xF5es",
+    optInit: "Gerar um plopfile.ts basico",
+    optInitJs: "Gerar um plopfile.js basico",
+    optInitTs: "Gerar um plopfile.ts basico",
+    optDemo: "Gerar um gerador de demo no plopfile",
+    optI18n: "Inicializar o plopfile com suporte i18n",
+    optGenerate: "Gerar um modelo: locale | textos | tema",
+    optPath: "Diret\xF3rio de sa\xEDda base para os arquivos de modelo gerados",
+    optExtension: "Extens\xE3o de arquivo gerada: ts | js | json",
+    optIncludeCustomTexts: "Para a gera\xE7\xE3o de locale, incluir as chaves traduz\xEDveis do plopfile",
+    optVersion: "Mostrar a versao atual",
+    optForce: "Executar o gerador em modo forcado",
+    optLang: "Forcar a locale de exibicao (ex. en, es, fr, pt)",
+    danger: "o perigo espera quem se aventura abaixo desta linha",
+    lowPlopfile: "Caminho para o plopfile",
+    lowCwd: "Diretorio base para calcular caminhos relativos durante a busca do plopfile",
+    lowPreload: "String ou array de modulos para carregar antes do plop-next",
+    lowDest: "Escrever a saida nesta pasta em vez da pasta pai do plopfile",
+    lowNoProgress: "Desativar o spinner de progresso",
+    examples: "Exemplos:"
+  }
+};
+
+// src/locales/zh.ts
+var ZH_MESSAGES = {
+  cli: {
+    title: "\u6B22\u8FCE\u4F7F\u7528 plop-next! \u{1F680}",
+    welcomeMessage: null,
+    selectGenerator: "\u8BF7\u9009\u62E9\u4E00\u4E2A\u751F\u6210\u5668",
+    noGenerators: "\u672A\u6CE8\u518C\u4EFB\u4F55\u751F\u6210\u5668\u3002\u8BF7\u5728\u60A8\u7684 plopfile \u4E2D\u6DFB\u52A0\u3002",
+    generatorNotFound: (name) => `\u672A\u627E\u5230\u751F\u6210\u5668 "${name}"\u3002`,
+    aborted: "\u5DF2\u53D6\u6D88\u3002",
+    done: "\u5B8C\u6210\uFF01",
+    promptCancelled: "\u7528\u6237\u5173\u95ED\u4E86\u63A7\u5236\u53F0\u3002"
+  },
+  inquirer: {
+    confirm: {
+      yesLabel: "\u662F",
+      noLabel: "\u5426",
+      hintYes: "\u662F/\u5426",
+      hintNo: "\u662F/\u5426"
+    },
+    select: {
+      helpNavigate: "\u5BFC\u822A",
+      helpSelect: "\u9009\u62E9"
+    },
+    checkbox: {
+      helpNavigate: "\u5BFC\u822A",
+      helpSelect: "\u9009\u62E9",
+      helpSubmit: "\u63D0\u4EA4",
+      helpAll: "\u5168\u9009",
+      helpInvert: "\u53CD\u9009"
+    },
+    search: {
+      helpNavigate: "\u5BFC\u822A",
+      helpSelect: "\u9009\u62E9"
+    },
+    editor: {
+      waitingMessage: (enterKey) => `\u6309 ${enterKey} \u952E\u542F\u52A8\u60A8\u7684\u9996\u9009\u7F16\u8F91\u5668\u3002`
+    },
+    password: {
+      maskedText: "[\u8F93\u5165\u5DF2\u9690\u85CF]"
+    }
+  },
+  actions: {
+    add: {
+      creating: (path) => `\u6B63\u5728\u521B\u5EFA ${path}`,
+      created: (path) => `\u2714 \u5DF2\u521B\u5EFA ${path}`,
+      alreadyExists: (path) => `\u6587\u4EF6\u5DF2\u5B58\u5728: ${path}`
+    },
+    modify: {
+      modifying: (path) => `\u6B63\u5728\u4FEE\u6539 ${path}`,
+      modified: (path) => `\u2714 \u5DF2\u4FEE\u6539 ${path}`,
+      notFound: (path) => `\u672A\u627E\u5230\u6587\u4EF6: ${path}`,
+      patternNotFound: (path) => `\u5728\u4EE5\u4E0B\u6587\u4EF6\u4E2D\u672A\u627E\u5230\u6A21\u5F0F: ${path}`
+    },
+    append: {
+      appending: (path) => `\u6B63\u5728\u8FFD\u52A0\u5230 ${path}`,
+      appended: (path) => `\u2714 \u5DF2\u8FFD\u52A0\u5230 ${path}`
+    }
+  },
+  errors: {
+    unknownAction: (type) => `\u672A\u77E5\u7684\u64CD\u4F5C\u7C7B\u578B: "${type}"`,
+    plopfileNotFound: "\u627E\u4E0D\u5230 plopfile (plopfile.js \u6216 plopfile.ts)\u3002",
+    plopfileLoadFailed: (err) => `\u52A0\u8F7D plopfile \u5931\u8D25: ${err}`,
+    generatorNotFound: (name) => `\u672A\u627E\u5230\u751F\u6210\u5668 "${name}"\u3002`,
+    noGenerators: "\u672A\u6CE8\u518C\u4EFB\u4F55\u751F\u6210\u5668\u3002\u8BF7\u5728\u60A8\u7684 plopfile \u4E2D\u6DFB\u52A0\u3002",
+    invalidPrompt: (name, reason) => `\u65E0\u6548\u7684 prompt "${name}": ${reason}`,
+    bypassParse: (promptName, promptType, value, detail) => `\u65E0\u6CD5\u5C06 bypass \u503C "${value}" \u8D4B\u7ED9 prompt ${promptType} "${promptName}"${detail ? `: ${detail}` : ""}`,
+    plopfileLoad: (path) => `\u52A0\u8F7D plopfile \u5931\u8D25: ${path}`,
+    plopfileExport: "plopfile \u5FC5\u987B\u5BFC\u51FA\u4E00\u4E2A\u9ED8\u8BA4\u51FD\u6570\u3002",
+    userCancelled: "\u7528\u6237\u53D6\u6D88\u4E86 prompt\u3002",
+    plopfileNotFoundWarning: "\u672A\u627E\u5230 plopfile\u3002\u8BF7\u5728\u9879\u76EE\u4E2D\u521B\u5EFA plopfile.js\u3002",
+    forcedLangI18nMissing: (locale) => `\u5F3A\u5236\u8BED\u8A00 "${locale}" \u5DF2\u88AB\u5FFD\u7565\uFF0C\u56E0\u4E3A\u672A\u5B89\u88C5 @plop-next/i18n\u3002\u5C06\u56DE\u9000\u5230\u82F1\u6587\u3002`,
+    forcedLangUnavailable: (locale) => `\u5F3A\u5236\u8BED\u8A00 "${locale}" \u4E0D\u53EF\u7528\u3002\u5C06\u56DE\u9000\u5230\u82F1\u6587\u3002`
+  },
+  /**
+   * CLI `--help` display texts — Chinese.
+   * Read-only: cannot be overridden via `registerLocale` / `registerTexts`.
+   */
+  help: {
+    usage: "\u7528\u6CD5:",
+    usage1: "\u4ECE\u53EF\u7528\u751F\u6210\u5668\u5217\u8868\u4E2D\u9009\u62E9",
+    usage2: "\u6267\u884C\u4EE5\u8BE5\u540D\u79F0\u6CE8\u518C\u7684\u751F\u6210\u5668",
+    usage3: "\u6267\u884C\u751F\u6210\u5668\u5E76\u4F20\u5165\u8F93\u5165\u6570\u636E\u4EE5\u8DF3\u8FC7 prompts",
+    options: "\u9009\u9879:",
+    optHelp: "\u663E\u793A\u5E2E\u52A9",
+    optShowTypeNames: "\u663E\u793A\u5B8C\u6574\u7C7B\u578B\u540D\u79F0\u800C\u4E0D\u662F\u7F29\u5199",
+    optInitTitle: "Plopfile \u521D\u59CB\u5316",
+    optGenerateTitle: "\u751F\u6210 Locale\u3001Texts\u3001Theme \u6587\u4EF6",
+    optOthersTitle: "\u5176\u4ED6\u9009\u9879",
+    optInit: "\u751F\u6210\u57FA\u7840 plopfile.ts",
+    optInitJs: "\u751F\u6210\u57FA\u7840 plopfile.js",
+    optInitTs: "\u751F\u6210\u57FA\u7840 plopfile.ts",
+    optDemo: "\u5728 plopfile \u4E2D\u751F\u6210\u4E00\u4E2A demo \u751F\u6210\u5668",
+    optI18n: "\u4EE5 i18n \u652F\u6301\u521D\u59CB\u5316 plopfile",
+    optGenerate: "\u751F\u6210\u4E00\u4E2A\u6A21\u578B: locale | texts | theme",
+    optPath: "\u751F\u6210\u7684\u6A21\u578B\u6587\u4EF6\u7684\u57FA\u7840\u8F93\u51FA\u76EE\u5F55",
+    optExtension: "\u751F\u6210\u7684\u6587\u4EF6\u6269\u5C55\u540D: ts | js | json",
+    optIncludeCustomTexts: "\u5BF9\u4E8E locale \u751F\u6210\uFF0C\u5305\u62EC plopfile \u4E2D\u53EF\u7FFB\u8BD1\u7684\u952E",
+    optVersion: "\u663E\u793A\u5F53\u524D\u7248\u672C",
+    optForce: "\u4EE5\u5F3A\u5236\u6A21\u5F0F\u6267\u884C\u751F\u6210\u5668",
+    optLang: "\u5F3A\u5236\u663E\u793A\u8BED\u8A00 (\u4F8B\u5982 en, es, fr, pt, zh)",
+    danger: "\u8DE8\u8FC7\u6B64\u7EBF\uFF0C\u98CE\u9669\u81EA\u8D1F",
+    lowPlopfile: "plopfile \u8DEF\u5F84",
+    lowCwd: "\u5728\u67E5\u627E plopfile \u65F6\u7528\u4E8E\u8BA1\u7B97\u76F8\u5BF9\u8DEF\u5F84\u7684\u57FA\u7840\u76EE\u5F55",
+    lowPreload: "\u5728 plop-next \u4E4B\u524D\u52A0\u8F7D\u7684\u6A21\u5757\u5B57\u7B26\u4E32\u6216\u6570\u7EC4",
+    lowDest: "\u5C06\u8F93\u51FA\u5199\u5165\u6B64\u76EE\u5F55\uFF0C\u800C\u4E0D\u662F plopfile \u7684\u7236\u76EE\u5F55",
+    lowNoProgress: "\u7981\u7528\u8FDB\u5EA6 spinner",
+    examples: "\u793A\u4F8B:"
+  }
+};
+
+// src/I18nRegistry.ts
+function resolvePath(obj, path) {
+  return path.split(".").reduce(
+    (acc, key) => acc !== null && typeof acc === "object" ? acc[key] : void 0,
+    obj
+  );
+}
+var I18nRegistry = class {
+  constructor() {
+    this.locales = /* @__PURE__ */ new Map();
+    this.activeLocale = BASE_LOCALE;
+    this.locales.set(BASE_LOCALE, EN_MESSAGES);
+    this.locales.set("es", ES_MESSAGES);
+    this.locales.set("fr", FR_MESSAGES);
+    this.locales.set("pt", PT_MESSAGES);
+    this.locales.set("zh", ZH_MESSAGES);
+  }
+  registerTexts(locale, texts) {
+    const existing = this.locales.get(locale) ?? {};
+    const { help: _ignored, ...safeTexts } = texts;
+    this.locales.set(locale, this.deepMerge(existing, safeTexts));
+  }
+  registerText(locale, path, text) {
+    if (path === "help" || path.startsWith("help.")) return;
+    const keys = path.split(".").filter(Boolean);
+    const nested = keys.reduceRight((acc, key) => ({ [key]: acc }), text);
+    this.registerTexts(locale, nested);
+  }
+  registerLocale(locale, texts) {
+    if (!this.locales.has(locale)) {
+      const parentHelp = this.resolveParentHelpTexts(locale);
+      const seed = parentHelp ? { help: parentHelp } : {};
+      this.locales.set(locale, seed);
+    }
+    this.registerTexts(locale, texts);
+  }
+  setActiveLocale(locale) {
+    this.activeLocale = locale;
+  }
+  getActiveLocale() {
+    return this.activeLocale;
+  }
+  hasLocale(locale) {
+    return this.locales.has(locale);
+  }
+  getLocaleValue(locale, key) {
+    const localeEntry = this.locales.get(locale);
+    if (!localeEntry) {
+      return void 0;
+    }
+    return resolvePath(localeEntry, key);
+  }
+  t(key, args = [], defaultMessage) {
+    const value = this.findValue(key);
+    if (value !== void 0) {
+      return typeof value === "function" ? String(value(...args)) : String(value);
+    }
+    if (defaultMessage !== void 0) {
+      return typeof defaultMessage === "function" ? defaultMessage(...args) : defaultMessage;
+    }
+    return key;
+  }
+  findValue(key) {
+    const active = this.locales.get(this.activeLocale);
+    const inActive = active ? resolvePath(active, key) : void 0;
+    if (inActive !== void 0) return inActive;
+    if (this.activeLocale !== BASE_LOCALE) {
+      const en = this.locales.get(BASE_LOCALE);
+      const inEn = en ? resolvePath(en, key) : void 0;
+      if (inEn !== void 0) return inEn;
+    }
+    return void 0;
+  }
+  /**
+   * Returns the `help` texts for the given locale, walking up parent locales
+   * (e.g. "fr-BE" → "fr" → "en") until a `help` section is found.
+   * Always returns at least the English default help texts.
+   */
+  getHelpTexts(locale) {
+    for (const candidate of this.parentLocaleChain(locale)) {
+      const entry = this.locales.get(candidate);
+      if (entry && typeof entry["help"] === "object" && entry["help"] !== null) {
+        return entry["help"];
+      }
+    }
+    const en = this.locales.get(BASE_LOCALE);
+    return en?.["help"] ?? {};
+  }
+  /**
+   * Resolves help texts from the closest parent locale of `locale`.
+   * Returns `undefined` if no parent locale has help texts.
+   */
+  resolveParentHelpTexts(locale) {
+    const chain = this.parentLocaleChain(locale);
+    for (const candidate of chain.slice(1)) {
+      const entry = this.locales.get(candidate);
+      if (entry && typeof entry["help"] === "object" && entry["help"] !== null) {
+        return entry["help"];
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Returns an ordered list of candidate locales to try for `locale`.
+   * E.g. "fr-BE" → ["fr-BE", "fr", "en"]
+   */
+  parentLocaleChain(locale) {
+    const chain = [locale];
+    const parts = locale.split(/[-_]/);
+    for (let i = parts.length - 1; i > 0; i--) {
+      chain.push(parts.slice(0, i).join("-"));
+    }
+    if (!chain.includes(BASE_LOCALE)) chain.push(BASE_LOCALE);
+    return chain;
+  }
+  deepMerge(target, source) {
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof target[key] === "object" && target[key] !== null) {
+        result[key] = this.deepMerge(
+          target[key],
+          value
+        );
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+};
+
+// src/PlopNextI18n.ts
+var requireModule = createRequire(import.meta.url);
+var SUPPORTED_I18N_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".json",
+  ".js",
+  ".cjs",
+  ".ts",
+  ".cts"
+]);
+var SCOPED_LOCALE_FILE_PATTERN = /^([a-z]{2}(?:[-_][A-Za-z0-9]{2,8})*)\.locale\.(ts|js|json)$/i;
+var SCOPED_TEXTS_FILE_PATTERN = /^([a-z]{2}(?:[-_][A-Za-z0-9]{2,8})*)\.texts\.(ts|js|json)$/i;
+var RuntimeI18nSourceWarning = class _RuntimeI18nSourceWarning extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "I18N_SOURCE_WARNING";
+    this.isOperational = true;
+    this.config = {
+      isWarning: true,
+      shouldExit: false,
+      exitCode: 0,
+      showStackTrace: false,
+      allowLogFile: false
+    };
+    this.name = "RuntimeI18nSourceWarning";
+    Object.setPrototypeOf(this, _RuntimeI18nSourceWarning.prototype);
+  }
+};
+var PlopNextI18n = class {
+  constructor(core) {
+    this.core = core;
+    this.registry = new I18nRegistry();
+    this.enabled = false;
+    this.translatableRules = /* @__PURE__ */ new Map();
+    this.install();
+  }
+  install() {
+    const adapter = {
+      t: (key, args, fallback) => this.registry.t(key, args, fallback),
+      preparePrompts: (generatorName, prompts) => this.preparePrompts(generatorName, prompts),
+      getWelcomeMessage: () => {
+        const activeLocale = this.registry.getActiveLocale();
+        const activeValue = this.resolveWelcomeMessageForLocale(activeLocale);
+        if (activeValue !== null) {
+          return activeValue;
+        }
+        if (activeLocale === "en") {
+          return null;
+        }
+        return this.resolveWelcomeMessageForLocale("en");
+      },
+      use: (options) => this.enable(options),
+      isEnabled: () => this.enabled,
+      hasLocale: (locale) => this.registry.hasLocale(locale),
+      registerLocale: (locale, messages, options) => {
+        this.registerLocale(locale, messages, options);
+      },
+      registerLocales: (locales, options) => {
+        this.registerLocales(locales, options);
+      },
+      registerTexts: (localeOrTexts, maybeTexts) => {
+        if (typeof maybeTexts === "undefined") {
+          this.registerTexts(localeOrTexts);
+          return;
+        }
+        this.registerTexts(localeOrTexts, maybeTexts);
+      },
+      registerText: (locale, path, text) => {
+        this.registerText(locale, path, text);
+      },
+      setLocale: (locale) => {
+        this.registry.setActiveLocale(locale);
+      },
+      getLocale: () => this.registry.getActiveLocale(),
+      registerTranslatableFields: (promptType, rules) => {
+        const existing = this.translatableRules.get(promptType) ?? [];
+        this.translatableRules.set(promptType, [...existing, ...rules]);
+      }
+    };
+    this.core.setI18nAdapter(adapter);
+    return this;
+  }
+  /**
+   * Register (or extend) a locale's message map.
+   * Merges deeply with any previously registered messages for that locale.
+   *
+   * @param locale   BCP-47 tag, e.g. "fr", "es", "ja"
+   * @param messages Flat or nested translation map
+   * @param options  `activate: true` sets this locale as active immediately
+   */
+  registerLocale(locale, texts, options = {}) {
+    this.registry.registerLocale(
+      locale,
+      this.resolveSingleLocaleTexts(locale, texts)
+    );
+    if (options.activate) {
+      this.registry.setActiveLocale(locale);
+    }
+    return this;
+  }
+  registerLocales(locales, options = {}) {
+    const resolved = this.resolveLocalesOrSingle(
+      locales,
+      this.registry.getActiveLocale(),
+      "locales"
+    );
+    if (this.isLocalesBundle(resolved)) {
+      const entries = Object.entries(resolved);
+      for (const [locale, texts] of entries) {
+        this.registry.registerLocale(locale, texts);
+      }
+      if (options.activate && entries[0]) {
+        this.registry.setActiveLocale(entries[0][0]);
+      }
+      return this;
+    }
+    const active = this.registry.getActiveLocale();
+    this.registry.registerLocale(active, resolved);
+    if (options.activate) {
+      this.registry.setActiveLocale(active);
+    }
+    return this;
+  }
+  registerTexts(localeOrTexts, maybeTexts) {
+    if (typeof localeOrTexts === "string" && typeof maybeTexts !== "undefined") {
+      this.registry.registerTexts(
+        localeOrTexts,
+        this.resolveSingleLocaleTexts(localeOrTexts, maybeTexts)
+      );
+      return this;
+    }
+    const resolved = this.resolveLocalesOrSingle(
+      localeOrTexts,
+      this.registry.getActiveLocale(),
+      "texts"
+    );
+    if (this.isLocalesBundle(resolved)) {
+      for (const [locale, texts] of Object.entries(resolved)) {
+        this.registry.registerTexts(locale, texts);
+      }
+      return this;
+    }
+    this.registry.registerTexts(this.registry.getActiveLocale(), resolved);
+    return this;
+  }
+  /**
+   * Override a single text value identified by a dot-notation path.
+   *
+   * @param locale  Locale tag, e.g. "fr"
+   * @param path    Dot-notation key, e.g. "cli.selectGenerator"
+   * @param text    The translated string or function
+   *
+   * @example
+   * i18n.registerText("fr", "cli.selectGenerator", "Choisissez un générateur");
+   */
+  registerText(locale, path, text) {
+    this.registry.registerText(locale, path, text);
+    return this;
+  }
+  /**
+   * Return the currently active locale tag.
+   */
+  getActiveLocale() {
+    return this.registry.getActiveLocale();
+  }
+  /**
+   * Check if a locale has been registered.
+   */
+  hasLocale(locale) {
+    return this.registry.hasLocale(locale);
+  }
+  resolveSingleLocaleTexts(locale, input) {
+    const resolved = this.resolveLocalesOrSingle(input, locale, "locale");
+    if (this.isLocalesBundle(resolved)) {
+      if (resolved[locale]) {
+        return resolved[locale];
+      }
+      const entries = Object.entries(resolved);
+      if (entries.length === 1 && entries[0]) {
+        return entries[0][1];
+      }
+      throw new Error(
+        `Unable to resolve texts for locale "${locale}" from a multi-locale source.`
+      );
+    }
+    return resolved;
+  }
+  resolveLocalesOrSingle(input, fallbackLocale, intent) {
+    if (typeof input === "string") {
+      return this.resolveFromPath(input, fallbackLocale, intent);
+    }
+    if (!this.isPlainObject(input)) {
+      throw new Error(
+        "i18n source must be an object, a locale file path (.json/.js/.cjs/.ts/.cts), or a directory path."
+      );
+    }
+    return this.normalizeObjectInput(input, fallbackLocale, intent);
+  }
+  resolveFromPath(inputPath, fallbackLocale, intent) {
+    const absolutePath = isAbsolute(inputPath) ? inputPath : resolve(process.cwd(), inputPath);
+    if (!existsSync(absolutePath)) {
+      throw new Error(`i18n path not found: ${absolutePath}`);
+    }
+    const stats = statSync(absolutePath);
+    if (stats.isDirectory()) {
+      if (intent === "locales" || intent === "texts") {
+        return this.resolveScopedDirectory(absolutePath, fallbackLocale, intent);
+      }
+      const files = readdirSync(absolutePath).filter(
+        (name) => SUPPORTED_I18N_FILE_EXTENSIONS.has(extname(name).toLowerCase())
+      ).sort();
+      if (files.length === 0) {
+        throw new Error(
+          `No locale/text files found in directory: ${absolutePath}. Supported extensions: .json, .js, .cjs, .ts, .cts.`
+        );
+      }
+      const bundle = {};
+      for (const fileName of files) {
+        const filePath = resolve(absolutePath, fileName);
+        const parsed2 = this.parseSourceFile(filePath);
+        const normalized = this.normalizeObjectInput(
+          parsed2,
+          fallbackLocale,
+          intent
+        );
+        if (this.isLocalesBundle(normalized)) {
+          for (const [locale2, texts] of Object.entries(normalized)) {
+            bundle[locale2] = this.mergePlainObjects(
+              bundle[locale2] ?? {},
+              texts
+            );
+          }
+          continue;
+        }
+        const locale = basename(fileName, extname(fileName));
+        if (!this.isLocaleLikeKey(locale) && intent !== "locale") {
+          throw new Error(
+            `Invalid ${intent} file name "${fileName}" in directory: ${absolutePath}. Expected a locale-like name such as "en.json", "fr.js", or "de.ts".`
+          );
+        }
+        const targetLocale = this.isLocaleLikeKey(locale) ? locale : fallbackLocale;
+        bundle[targetLocale] = this.mergePlainObjects(
+          bundle[targetLocale] ?? {},
+          normalized
+        );
+      }
+      return bundle;
+    }
+    const parsed = this.parseSourceFile(absolutePath);
+    return this.normalizeObjectInput(parsed, fallbackLocale, intent);
+  }
+  resolveScopedDirectory(absolutePath, fallbackLocale, intent) {
+    const files = readdirSync(absolutePath).sort();
+    const bundle = {};
+    let matchedFiles = 0;
+    for (const fileName of files) {
+      const match = intent === "locales" ? fileName.match(SCOPED_LOCALE_FILE_PATTERN) : fileName.match(SCOPED_TEXTS_FILE_PATTERN);
+      if (!match) {
+        continue;
+      }
+      matchedFiles += 1;
+      const locale = match[1];
+      if (!locale || !this.isLocaleLikeKey(locale)) {
+        this.emitI18nSourceWarning(
+          `Invalid ${intent} file name "${fileName}" in directory: ${absolutePath}. Expected format "<locale>.${intent === "locales" ? "locale" : "texts"}.<ts|js|json>".`
+        );
+        continue;
+      }
+      const filePath = resolve(absolutePath, fileName);
+      const scopedSource = this.parseScopedSourceFile(filePath, intent, locale);
+      if (!scopedSource) {
+        continue;
+      }
+      const normalized = this.normalizeObjectInput(
+        scopedSource,
+        fallbackLocale,
+        intent
+      );
+      if (this.isLocalesBundle(normalized)) {
+        for (const [localeKey, texts] of Object.entries(normalized)) {
+          bundle[localeKey] = this.mergePlainObjects(
+            bundle[localeKey] ?? {},
+            texts
+          );
+        }
+        continue;
+      }
+      bundle[locale] = this.mergePlainObjects(bundle[locale] ?? {}, normalized);
+    }
+    if (matchedFiles === 0) {
+      throw new Error(
+        `No ${intent} files found in directory: ${absolutePath}. Expected "<locale>.${intent === "locales" ? "locale" : "texts"}.<ts|js|json>" files.`
+      );
+    }
+    return bundle;
+  }
+  parseScopedSourceFile(filePath, intent, fileLocale) {
+    const extension = extname(filePath).toLowerCase();
+    if (extension === ".json") {
+      const parsed = this.parseJsonFile(filePath);
+      const extracted2 = this.extractScopedObject(
+        parsed,
+        intent,
+        filePath,
+        fileLocale
+      );
+      if (!extracted2) {
+        return void 0;
+      }
+      if (this.looksLikeThemeObject(extracted2)) {
+        this.emitI18nSourceWarning(
+          `Ignored ${intent} file at ${filePath}: looks like a theme object.`
+        );
+        return void 0;
+      }
+      return extracted2;
+    }
+    if (!SUPPORTED_I18N_FILE_EXTENSIONS.has(extension)) {
+      this.emitI18nSourceWarning(
+        `Ignored ${intent} file at ${filePath}: unsupported extension "${extension || "<none>"}".`
+      );
+      return void 0;
+    }
+    let loaded;
+    try {
+      loaded = requireModule(filePath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Unable to load i18n module at ${filePath}: ${message}. If this file is ESM-only, import it in your plopfile and pass the object directly.`
+      );
+    }
+    const extracted = this.extractScopedObject(
+      loaded,
+      intent,
+      filePath,
+      fileLocale
+    );
+    if (!extracted) {
+      return void 0;
+    }
+    if (this.looksLikeThemeObject(extracted)) {
+      this.emitI18nSourceWarning(
+        `Ignored ${intent} file at ${filePath}: looks like a theme object.`
+      );
+      return void 0;
+    }
+    return extracted;
+  }
+  extractScopedObject(source, intent, filePath, fileLocale) {
+    if (!this.isPlainObject(source)) {
+      this.emitI18nSourceWarning(
+        `Ignored ${intent} file at ${filePath}: source must be an object.`
+      );
+      return void 0;
+    }
+    const record = source;
+    const selectorKeys = intent === "locales" ? ["locale", "Locale", "local", "Local"] : ["texts", "Texts", "text", "Text"];
+    for (const key of selectorKeys) {
+      if (!Object.prototype.hasOwnProperty.call(record, key)) {
+        continue;
+      }
+      const selected = record[key];
+      if (this.isPlainObject(selected)) {
+        return selected;
+      }
+      this.emitI18nSourceWarning(
+        `Ignored ${intent} file at ${filePath}: "${key}" must be an object.`
+      );
+      return void 0;
+    }
+    if (Object.prototype.hasOwnProperty.call(record, "default")) {
+      const selected = record.default;
+      if (this.isPlainObject(selected)) {
+        return selected;
+      }
+      this.emitI18nSourceWarning(
+        `Ignored ${intent} file at ${filePath}: default export must be an object.`
+      );
+      return void 0;
+    }
+    const matchedLocaleKey = this.findLocaleExportKey(record, fileLocale);
+    if (matchedLocaleKey) {
+      const selected = record[matchedLocaleKey];
+      if (this.isPlainObject(selected)) {
+        return selected;
+      }
+      this.emitI18nSourceWarning(
+        `Ignored ${intent} file at ${filePath}: "${matchedLocaleKey}" export must be an object.`
+      );
+      return void 0;
+    }
+    this.emitI18nSourceWarning(
+      `Ignored ${intent} file at ${filePath}: expected a named export "${intent === "locales" ? "locale" : "texts"}", a locale export matching "${fileLocale}" (e.g. "${fileLocale.toLowerCase()}" or "${fileLocale.toUpperCase()}"), or a default export object.`
+    );
+    return void 0;
+  }
+  findLocaleExportKey(record, locale) {
+    const expected = this.normalizeLocaleTag(locale);
+    for (const key of Object.keys(record)) {
+      if (this.normalizeLocaleTag(key) === expected) {
+        return key;
+      }
+    }
+    return void 0;
+  }
+  normalizeLocaleTag(value) {
+    return value.trim().replace(/_/g, "-").toLowerCase();
+  }
+  resolveWelcomeMessageForLocale(locale) {
+    const candidateKeys = ["cli.welcomeMessage", "welcomeMessage"];
+    for (const key of candidateKeys) {
+      const value = this.registry.getLocaleValue(locale, key);
+      if (typeof value === "string") {
+        return value;
+      }
+    }
+    return null;
+  }
+  emitI18nSourceWarning(message) {
+    const warning = new RuntimeI18nSourceWarning(message);
+    const reporter = this.core.reportWarning;
+    if (typeof reporter === "function") {
+      reporter.call(this.core, warning);
+      return;
+    }
+    console.warn(warning.message);
+  }
+  parseSourceFile(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    if (extension === ".json") {
+      return this.parseJsonFile(filePath);
+    }
+    if (!SUPPORTED_I18N_FILE_EXTENSIONS.has(extension)) {
+      throw new Error(
+        `Unsupported i18n file extension "${extension || "<none>"}" at ${filePath}. Supported extensions: .json, .js, .cjs, .ts, .cts.`
+      );
+    }
+    return this.parseModuleFile(filePath);
+  }
+  parseJsonFile(filePath) {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    } catch (error) {
+      throw new Error(
+        `Invalid JSON file at ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (!this.isPlainObject(parsed)) {
+      throw new Error(`JSON file must contain an object at root: ${filePath}`);
+    }
+    return parsed;
+  }
+  parseModuleFile(filePath) {
+    let loaded;
+    try {
+      loaded = requireModule(filePath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Unable to load i18n module at ${filePath}: ${message}. If this file is ESM-only, import it in your plopfile and pass the object directly.`
+      );
+    }
+    const unwrapped = this.unwrapModuleDefault(loaded);
+    const value = typeof unwrapped === "function" ? this.unwrapModuleDefault(unwrapped()) : unwrapped;
+    if (!this.isPlainObject(value)) {
+      throw new Error(`i18n module must export an object at root: ${filePath}`);
+    }
+    return value;
+  }
+  normalizeObjectInput(input, fallbackLocale, intent) {
+    if (this.looksLikeThemeObject(input)) {
+      throw new Error(
+        `Invalid ${intent} source: looks like a theme object. Use core.setTheme(pathOrTheme) for theme files.`
+      );
+    }
+    if (this.isLocalesBundle(input)) {
+      return input;
+    }
+    if (this.isPlainObject(input)) {
+      return input;
+    }
+    return { [fallbackLocale]: input };
+  }
+  isLocalesBundle(value) {
+    if (!this.isPlainObject(value)) {
+      return false;
+    }
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return false;
+    }
+    return entries.every(
+      ([key, val]) => this.isLocaleLikeKey(key) && this.isPlainObject(val)
+    );
+  }
+  isLocaleLikeKey(key) {
+    return /^[a-z]{2}(?:[-_][A-Za-z0-9]{2,8})*$/i.test(key);
+  }
+  looksLikeThemeObject(value) {
+    if (!this.isPlainObject(value)) {
+      return false;
+    }
+    const keys = Object.keys(value);
+    if (keys.length === 0) {
+      return false;
+    }
+    const directThemeKeys = /* @__PURE__ */ new Set([
+      "icon",
+      "prefix",
+      "spinner",
+      "style",
+      "validationFailureMode",
+      "indexMode",
+      "i18n",
+      "keybindings",
+      "plopNext",
+      "waitingMessage",
+      "maskedText",
+      "disabledError",
+      "input",
+      "select",
+      "generatorList",
+      "list",
+      "checkbox",
+      "confirm",
+      "search",
+      "password",
+      "expand",
+      "editor",
+      "number",
+      "rawlist"
+    ]);
+    return keys.some((key) => directThemeKeys.has(key));
+  }
+  isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+  unwrapModuleDefault(value) {
+    if (!this.isPlainObject(value)) {
+      return value;
+    }
+    if (typeof value.default !== "undefined") {
+      return value.default;
+    }
+    return value;
+  }
+  mergePlainObjects(target, source) {
+    const out = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+      if (this.isPlainObject(value) && this.isPlainObject(out[key])) {
+        out[key] = this.mergePlainObjects(out[key], value);
+      } else {
+        out[key] = value;
+      }
+    }
+    return out;
+  }
+  normalize(value) {
+    const [withoutEncoding = ""] = value.split(".");
+    const [lang = ""] = withoutEncoding.split(/[_-]/);
+    return lang.toLowerCase();
+  }
+  enable(options = { auto: true }) {
+    this.enabled = true;
+    const locale = options.force ?? (options.auto !== false ? this.detectLocale() : void 0);
+    if (locale) {
+      this.registry.setActiveLocale(locale);
+    }
+    this.applyInquirerLocale();
+  }
+  applyInquirerLocale() {
+    const locale = this.buildInquirerLocale();
+    const localized = createLocalizedPrompts(locale);
+    this.core.registerPrompt(
+      createConfirmHandler(localized.confirm)
+    );
+    this.core.registerPrompt(
+      createSelectHandler(localized.select)
+    );
+    this.core.registerPrompt(
+      createCheckboxHandler(localized.checkbox)
+    );
+    this.core.registerPrompt(
+      createSearchHandler(localized.search)
+    );
+    this.core.registerPrompt(
+      createEditorHandler(localized.editor)
+    );
+    this.core.registerPrompt(
+      createPasswordHandler(localized.password)
+    );
+  }
+  buildInquirerLocale() {
+    const t = (key, fallback) => {
+      const full = `inquirer.${key}`;
+      const val = this.registry.t(full);
+      return val === full ? fallback : val;
+    };
+    return {
+      confirm: {
+        yesLabel: t("confirm.yesLabel", "Yes"),
+        noLabel: t("confirm.noLabel", "No"),
+        hintYes: t("confirm.hintYes", "Y/n"),
+        hintNo: t("confirm.hintNo", "y/N")
+      },
+      select: {
+        helpNavigate: t("select.helpNavigate", "navigate"),
+        helpSelect: t("select.helpSelect", "select")
+      },
+      checkbox: {
+        helpNavigate: t("checkbox.helpNavigate", "navigate"),
+        helpSelect: t("checkbox.helpSelect", "select"),
+        helpSubmit: t("checkbox.helpSubmit", "submit"),
+        helpAll: t("checkbox.helpAll", "all"),
+        helpInvert: t("checkbox.helpInvert", "invert")
+      },
+      search: {
+        helpNavigate: t("search.helpNavigate", "navigate"),
+        helpSelect: t("search.helpSelect", "select")
+      },
+      editor: {
+        waitingMessage: (enterKey) => this.registry.t(
+          "inquirer.editor.waitingMessage",
+          [enterKey],
+          `Press ${enterKey} to launch your preferred editor.`
+        )
+      },
+      password: {
+        maskedText: t("password.maskedText", "[input is masked]")
+      }
+    };
+  }
+  detectLocale() {
+    for (const seg of (process.env["LANGUAGE"] ?? "").split(":")) {
+      const lang = this.normalize(seg);
+      if (lang) return lang;
+    }
+    for (const key of ["LC_ALL", "LC_MESSAGES", "LANG"]) {
+      const lang = this.normalize(process.env[key] ?? "");
+      if (lang) return lang;
+    }
+    try {
+      const lang = this.normalize(
+        Intl.DateTimeFormat().resolvedOptions().locale
+      );
+      if (lang) return lang;
+    } catch {
+    }
+    return "en";
+  }
+  preparePrompts(generatorName, prompts) {
+    if (!this.enabled) {
+      return prompts;
+    }
+    return prompts.map((prompt) => {
+      const resolvedPrompt = { ...prompt };
+      const resolvedPromptRecord = resolvedPrompt;
+      const messageFallback = typeof prompt.message === "string" ? prompt.message : void 0;
+      const message = this.resolvePromptField(
+        generatorName,
+        prompt.name,
+        "message",
+        messageFallback
+      );
+      if (message !== void 0) {
+        resolvedPrompt.message = message;
+      }
+      const promptRecord = prompt;
+      const choices = promptRecord["choices"];
+      if (Array.isArray(choices)) {
+        resolvedPromptRecord["choices"] = this.translateChoices(
+          generatorName,
+          prompt.name,
+          choices
+        );
+      } else if (typeof choices === "function") {
+        resolvedPromptRecord["choices"] = async (answers) => {
+          const rawChoices = await choices(answers);
+          return this.translateChoices(generatorName, prompt.name, rawChoices);
+        };
+      }
+      const translatableFields = [
+        "description",
+        "hint",
+        "instructions",
+        "helpText",
+        "noResults",
+        "searchingText"
+      ];
+      for (const field of translatableFields) {
+        const rawValue = resolvedPromptRecord[field];
+        const fallback = typeof rawValue === "string" ? rawValue : void 0;
+        const translated = this.resolvePromptField(
+          generatorName,
+          prompt.name,
+          field,
+          fallback
+        );
+        if (translated !== void 0) {
+          resolvedPromptRecord[field] = translated;
+        }
+      }
+      const customRules = this.translatableRules.get(prompt.type) ?? [];
+      for (const rule of customRules) {
+        this.applyRule(
+          resolvedPromptRecord,
+          rule,
+          `${generatorName}.${prompt.name}`
+        );
+      }
+      return resolvedPrompt;
+    });
+  }
+  /**
+   * Resolve a prompt field translation with fallback chain:
+   * 1. Try with prompt name as-is (handles both plain names and indexed names like "name[0]")
+   * 2. If that doesn't resolve, try without any index suffix (for indexed arrays)
+   * 3. Fall back to provided default
+   *
+   * @example
+   * // For promptName="name[0]" and field="message":
+   * // Tries: "component.name[0].message" → "component.name.message" → fallback
+   */
+  resolvePromptField(generatorName, promptName, field, fallback) {
+    const key = `${generatorName}.${promptName}.${field}`;
+    let resolved = this.registry.t(key, [], void 0);
+    if (resolved === key && /\[\d+\]/.test(promptName)) {
+      const nameWithoutIndex = promptName.replace(/\[\d+\]$/, "");
+      const fallbackKey = `${generatorName}.${nameWithoutIndex}.${field}`;
+      resolved = this.registry.t(fallbackKey, [], void 0);
+    }
+    if (resolved === key && typeof fallback !== "undefined") {
+      return fallback;
+    }
+    if (resolved === key) {
+      return void 0;
+    }
+    return resolved;
+  }
+  translateChoices(generatorName, promptName, choices) {
+    return choices.map((choice) => {
+      if (typeof choice === "string") {
+        const key = `${generatorName}.${promptName}.choices.${choice}`;
+        return this.registry.t(key, [], choice);
+      }
+      if (choice && typeof choice === "object") {
+        const rawName = choice.name;
+        if (typeof rawName !== "string") {
+          return choice;
+        }
+        const valueKey = this.choiceKey(choice);
+        const key = `${generatorName}.${promptName}.choices.${valueKey}`;
+        return {
+          ...choice,
+          name: this.registry.t(key, [], rawName)
+        };
+      }
+      return choice;
+    });
+  }
+  choiceKey(choice) {
+    if (typeof choice.value === "string" || typeof choice.value === "number") {
+      return String(choice.value);
+    }
+    return choice.name;
+  }
+  // ── Custom translatable-field engine ────────────────────────────────
+  /**
+   * Apply one translation rule to the (shallow-copied) prompt record.
+   *
+   * The implementation is purely functional: nested arrays / objects are
+   * reconstructed copy-on-write, so the original prompt config is never
+   * mutated.
+   */
+  applyRule(promptRecord, rule, keyBase) {
+    if (!rule.path) {
+      const fieldValue = promptRecord[rule.translateField];
+      if (typeof fieldValue === "string") {
+        const key = `${keyBase}.${rule.translateField}`;
+        const translated = this.registry.t(key, [], fieldValue);
+        if (translated !== fieldValue) {
+          promptRecord[rule.translateField] = translated;
+        }
+      }
+      return;
+    }
+    const hasWildcard = rule.path.includes("#");
+    const segments = !hasWildcard && rule.idField ? [...rule.path.split("."), "#"] : rule.path.split(".");
+    const firstSeg = segments[0];
+    if (!firstSeg) return;
+    const original = promptRecord[firstSeg];
+    const result = this.walkPath(
+      original,
+      segments,
+      1,
+      `${keyBase}.${firstSeg}`,
+      rule
+    );
+    if (result !== original) {
+      promptRecord[firstSeg] = result;
+    }
+  }
+  /**
+   * Recursively walk `segments` starting at `idx`, navigating into `current`.
+   * Returns a *new* value when a translation changed something, or `current`
+   * unchanged when nothing was modified (enabling cheap reference equality
+   * checks at every level).
+   */
+  walkPath(current, segments, idx, keyPath, rule) {
+    if (idx >= segments.length) {
+      return this.translateFieldValue(current, keyPath, rule.translateField);
+    }
+    const segment = segments[idx];
+    if (segment === "#") {
+      if (!Array.isArray(current)) return current;
+      const isLastHash = !segments.slice(idx + 1).includes("#");
+      let changed = false;
+      const newArr = current.map((item, index) => {
+        let keySegment;
+        if (isLastHash && rule.idField) {
+          const idVal = item !== null && typeof item === "object" && !Array.isArray(item) ? item[rule.idField] : void 0;
+          keySegment = idVal != null ? String(idVal) : String(index);
+        } else {
+          keySegment = String(index);
+        }
+        const newItem = this.walkPath(
+          item,
+          segments,
+          idx + 1,
+          `${keyPath}.${keySegment}`,
+          rule
+        );
+        if (newItem !== item) changed = true;
+        return newItem;
+      });
+      return changed ? newArr : current;
+    }
+    if (!current || typeof current !== "object" || Array.isArray(current))
+      return current;
+    const record = current;
+    const next = record[segment];
+    const newNext = this.walkPath(
+      next,
+      segments,
+      idx + 1,
+      `${keyPath}.${segment}`,
+      rule
+    );
+    if (newNext === next) return current;
+    return { ...record, [segment]: newNext };
+  }
+  /**
+   * Translate `fieldName` on `obj`. Returns a *new* object when the translation
+   * differs from the original value, or `obj` itself when nothing changed.
+   */
+  translateFieldValue(obj, keyPath, fieldName) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
+    const record = obj;
+    const fieldValue = record[fieldName];
+    if (typeof fieldValue !== "string") return obj;
+    const translated = this.registry.t(keyPath, [], fieldValue);
+    if (translated === fieldValue) return obj;
+    return { ...record, [fieldName]: translated };
+  }
+};
+export {
+  BASE_LOCALE,
+  DEFAULT_TEXTS_EN,
+  EN_MESSAGES,
+  ES_MESSAGES,
+  FR_MESSAGES,
+  I18nRegistry,
+  PT_MESSAGES,
+  PlopNextI18n,
+  ZH_MESSAGES
+};