@plop-next/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2871 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/picocolors/picocolors.js"(exports, module) {
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input2) => {
+      let string = "" + input2, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/ActionRunner.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, resolve, isAbsolute, relative, basename } from "path";
+import { glob } from "tinyglobby";
+var ActionRunner = class {
+  constructor(core, opts = {}) {
+    this.core = core;
+    this.opts = opts;
+  }
+  async run(type, config, answers) {
+    switch (type) {
+      case "add":
+        return this.runAdd(config, answers);
+      case "addMany":
+        return this.runAddMany(config, answers);
+      case "modify":
+        return this.runModify(config, answers);
+      case "append":
+        return this.runAppend(config, answers);
+      default:
+        throw new Error(this.core.t("errors.unknownAction", [type], `Unknown action type: "${type}"`));
+    }
+  }
+  async runAdd(config, answers) {
+    const path = this.interpolate(config.path ?? "", answers);
+    const absolutePath = this.toAbsolute(path);
+    const force = this.opts.force || config.force === true;
+    if (existsSync(absolutePath)) {
+      if (config.skipIfExists) {
+        return {
+          type: "skip",
+          message: `Skipped existing file: ${absolutePath}`,
+          path,
+          absolutePath
+        };
+      }
+      if (!force) {
+        throw new Error(this.core.t("actions.add.alreadyExists", [absolutePath], `File already exists: ${absolutePath}`));
+      }
+    }
+    let content = await this.resolveTemplate(config, answers);
+    content = await this.applyTransform(config, content, answers);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, content, "utf8");
+    return {
+      type: "add",
+      message: this.core.t("actions.add.created", [absolutePath], `Created ${absolutePath}`),
+      path,
+      absolutePath
+    };
+  }
+  async runAddMany(config, answers) {
+    const force = this.opts.force || config.force === true;
+    const destination = this.interpolate(config.destination ?? "", answers);
+    const destinationAbs = this.toAbsolute(destination);
+    const templatePatterns = config.templateFiles;
+    if (!templatePatterns) {
+      throw new Error("addMany requires templateFiles.");
+    }
+    const files = await glob(templatePatterns, {
+      cwd: this.core.getPlopfilePath() ? dirname(this.core.getPlopfilePath()) : process.cwd(),
+      ...config.globOptions ?? {}
+    });
+    const baseDir = config.base ? this.toAbsolute(this.interpolate(config.base, answers)) : void 0;
+    const stripExtensions = config.stripExtensions ?? ["hbs"];
+    let written = 0;
+    for (const file of files) {
+      const templatePath = this.toAbsolute(file);
+      const rel = baseDir ? relative(baseDir, templatePath) : basename(templatePath);
+      let outRel = rel;
+      for (const ext of stripExtensions) {
+        const suffix = `.${ext}`;
+        if (outRel.endsWith(suffix)) {
+          outRel = outRel.slice(0, -suffix.length);
+          break;
+        }
+      }
+      outRel = this.interpolate(outRel, answers);
+      const outputAbs = resolve(destinationAbs, outRel);
+      if (existsSync(outputAbs)) {
+        if (config.skipIfExists) {
+          continue;
+        }
+        if (!force) {
+          throw new Error(this.core.t("actions.add.alreadyExists", [outputAbs], `File already exists: ${outputAbs}`));
+        }
+      }
+      const raw = await readFile(templatePath, "utf8");
+      let content = this.interpolate(raw, { ...answers, ...config.data ?? {} });
+      content = await this.applyTransform(config, content, answers);
+      await mkdir(dirname(outputAbs), { recursive: true });
+      await writeFile(outputAbs, content, "utf8");
+      written += 1;
+    }
+    return {
+      type: "addMany",
+      message: `Added ${written} file(s) to ${destinationAbs}`,
+      path: destination,
+      absolutePath: destinationAbs
+    };
+  }
+  async runModify(config, answers) {
+    const path = this.interpolate(config.path ?? "", answers);
+    const absolutePath = this.toAbsolute(path);
+    if (!existsSync(absolutePath)) {
+      throw new Error(this.core.t("actions.modify.notFound", [absolutePath], `File not found: ${absolutePath}`));
+    }
+    let content = await readFile(absolutePath, "utf8");
+    const pattern = config.pattern instanceof RegExp ? config.pattern : new RegExp(config.pattern ?? "$", "g");
+    const replacement = await this.resolveTemplate(config, answers);
+    if (!pattern.test(content)) {
+      throw new Error(this.core.t("actions.modify.patternNotFound", [absolutePath], `Pattern not found in: ${absolutePath}`));
+    }
+    content = content.replace(pattern, replacement);
+    content = await this.applyTransform(config, content, answers);
+    await writeFile(absolutePath, content, "utf8");
+    return {
+      type: "modify",
+      message: this.core.t("actions.modify.modified", [absolutePath], `Modified ${absolutePath}`),
+      path,
+      absolutePath
+    };
+  }
+  async runAppend(config, answers) {
+    const path = this.interpolate(config.path ?? "", answers);
+    const absolutePath = this.toAbsolute(path);
+    const addition = await this.resolveTemplate(config, answers);
+    let existing = existsSync(absolutePath) ? await readFile(absolutePath, "utf8") : "";
+    const unique = config.unique !== false;
+    if (!(unique && existing.includes(addition))) {
+      if (config.pattern !== void 0) {
+        const pattern = config.pattern instanceof RegExp ? config.pattern : new RegExp(String(config.pattern), "g");
+        const separator = config.separator ?? "";
+        existing = existing.replace(pattern, (match) => `${match}${separator}${addition}`);
+      } else {
+        existing = `${existing}${addition}`;
+      }
+    }
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, existing, "utf8");
+    return {
+      type: "append",
+      message: this.core.t("actions.append.appended", [absolutePath], `Appended to ${absolutePath}`),
+      path,
+      absolutePath
+    };
+  }
+  async resolveTemplate(config, answers) {
+    const model = { ...answers, ...config.data ?? {} };
+    if (config.templateFile) {
+      const templateFile = this.resolveTemplateFilePath(config.templateFile);
+      const raw = await readFile(templateFile, "utf8");
+      return this.interpolate(raw, model);
+    }
+    return this.interpolate(config.template ?? "", model);
+  }
+  toAbsolute(path) {
+    if (isAbsolute(path)) return path;
+    return resolve(this.opts.dest ?? this.core.getDestBasePath(), path);
+  }
+  resolveTemplateFilePath(path) {
+    if (isAbsolute(path)) {
+      return path;
+    }
+    const plopfilePath = this.core.getPlopfilePath();
+    if (plopfilePath) {
+      return resolve(dirname(plopfilePath), path);
+    }
+    return resolve(this.core.getDestBasePath(), path);
+  }
+  interpolate(template, data) {
+    return this.core.renderString(template, data);
+  }
+  async applyTransform(config, content, answers) {
+    if (!config.transform) {
+      return content;
+    }
+    const transformed = await config.transform(content, {
+      ...answers,
+      ...config.data ?? {}
+    });
+    return transformed;
+  }
+};
+
+// src/PlopNextCore.ts
+import Handlebars from "handlebars";
+import { dirname as dirname2, extname, resolve as resolve2 } from "path";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { createRequire } from "module";
+import {
+  camelCase,
+  snakeCase,
+  dotCase,
+  pathCase,
+  sentenceCase,
+  constantCase,
+  kebabCase,
+  pascalCase
+} from "change-case";
+import { titleCase } from "title-case";
+
+// src/prompts/PromptHandlerRegistry.ts
+var PromptHandlerRegistry = class {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a handler for all its declared types.
+   * If a type is already registered, the new handler replaces the previous one,
+   * allowing built-in handlers to be overridden by plugins or users.
+   */
+  register(handler) {
+    for (const type of handler.types) {
+      this.map.set(type, handler);
+    }
+    return this;
+  }
+  /** Return the handler for the given type, or undefined if none is registered. */
+  get(type) {
+    return this.map.get(type);
+  }
+  /** True if a handler is registered for the given type. */
+  has(type) {
+    return this.map.has(type);
+  }
+  /** List of all registered type strings. */
+  getRegisteredTypes() {
+    return Array.from(this.map.keys());
+  }
+  /**
+   * Dispatch a prompt to the right handler.
+   *
+   * @param type   The prompt type string.
+   * @param config Prompt fields without plop-next-only keys.
+   * @returns      The user's answer.
+   * @throws       If no handler is registered for the type and no "input" fallback exists.
+   */
+  async ask(type, config, options = {}) {
+    const handler = this.map.get(type) ?? this.map.get("input");
+    if (!handler) {
+      throw new Error(
+        `No handler registered for prompt type "${type}". Register one with core.registerPrompt(handler).`
+      );
+    }
+    if (!options.allowTheme && Object.prototype.hasOwnProperty.call(config, "theme")) {
+      throw new Error(
+        `The "theme" prompt field is not supported in plop-next. Use core.setTheme({ ... }) instead.`
+      );
+    }
+    return handler.ask(type, config);
+  }
+};
+
+// src/prompts/inputPrompt.ts
+import { input } from "@inquirer/prompts";
+var inputPromptHandler = {
+  types: ["input"],
+  async ask(_type, config) {
+    const {
+      name: _name,
+      message,
+      default: defaultValue,
+      validate,
+      transformer,
+      pattern,
+      patternError,
+      prefill,
+      required,
+      ...rest
+    } = config;
+    const runInput = input;
+    return runInput({
+      message: String(message ?? ""),
+      ...defaultValue !== void 0 && { default: String(defaultValue) },
+      ...validate !== void 0 && {
+        validate
+      },
+      ...transformer !== void 0 && {
+        transformer
+      },
+      ...pattern !== void 0 && { pattern },
+      ...patternError !== void 0 && { patternError: String(patternError) },
+      ...prefill !== void 0 && { prefill },
+      ...required !== void 0 && { required: Boolean(required) },
+      ...rest
+    });
+  }
+};
+
+// src/prompts/numberPrompt.ts
+import { number as numberPrompt } from "@inquirer/prompts";
+var numberPromptHandler = {
+  types: ["number"],
+  async ask(_type, config) {
+    const {
+      name: _name,
+      message,
+      default: defaultValue,
+      min,
+      max,
+      step,
+      required,
+      validate,
+      theme,
+      ...rest
+    } = config;
+    const unsupportedKeys = Object.keys(rest);
+    if (unsupportedKeys.length > 0) {
+      throw new Error(
+        `Prompt type "number" does not support: ${unsupportedKeys.join(", ")}. Supported fields are: message, default, min, max, step, required, validate, theme.`
+      );
+    }
+    if (defaultValue !== void 0 && typeof defaultValue !== "number") {
+      throw new Error('Prompt type "number" expects "default" to be a number.');
+    }
+    if (min !== void 0 && typeof min !== "number") {
+      throw new Error('Prompt type "number" expects "min" to be a number.');
+    }
+    if (max !== void 0 && typeof max !== "number") {
+      throw new Error('Prompt type "number" expects "max" to be a number.');
+    }
+    if (step !== void 0 && step !== "any" && typeof step !== "number") {
+      throw new Error('Prompt type "number" expects "step" to be a number or "any".');
+    }
+    if (required !== void 0 && typeof required !== "boolean") {
+      throw new Error('Prompt type "number" expects "required" to be a boolean.');
+    }
+    if (validate !== void 0 && typeof validate !== "function") {
+      throw new Error('Prompt type "number" expects "validate" to be a function.');
+    }
+    const runNumberPrompt = numberPrompt;
+    return runNumberPrompt({
+      message: String(message ?? ""),
+      ...defaultValue !== void 0 && { default: defaultValue },
+      ...validate !== void 0 && {
+        validate
+      },
+      ...min !== void 0 && { min },
+      ...max !== void 0 && { max },
+      ...step !== void 0 && { step },
+      ...required !== void 0 && { required },
+      ...theme !== void 0 && { theme }
+    });
+  }
+};
+
+// src/prompts/confirmPrompt.ts
+import { confirm } from "@inquirer/prompts";
+function createConfirmHandler(fn) {
+  const confirmFn = fn ?? confirm;
+  return {
+    types: ["confirm"],
+    async ask(_type, config) {
+      const {
+        name: _name,
+        message,
+        default: defaultValue,
+        transformer,
+        theme,
+        ...rest
+      } = config;
+      const unsupportedKeys = Object.keys(rest);
+      if (unsupportedKeys.length > 0) {
+        throw new Error(
+          `Prompt type "confirm" does not support: ${unsupportedKeys.join(", ")}. Supported fields are: message, default, transformer, theme.`
+        );
+      }
+      if (defaultValue !== void 0 && typeof defaultValue !== "boolean") {
+        throw new Error('Prompt type "confirm" expects "default" to be a boolean.');
+      }
+      if (transformer !== void 0 && typeof transformer !== "function") {
+        throw new Error('Prompt type "confirm" expects "transformer" to be a function.');
+      }
+      return confirmFn({
+        message: String(message ?? ""),
+        ...defaultValue !== void 0 && { default: defaultValue },
+        ...transformer !== void 0 && {
+          transformer
+        },
+        ...theme !== void 0 && { theme }
+      });
+    }
+  };
+}
+var confirmPromptHandler = createConfirmHandler();
+
+// src/prompts/selectPrompt.ts
+import { select } from "@inquirer/prompts";
+function createSelectHandler(fn) {
+  const selectFn = fn ?? select;
+  return {
+    types: ["list", "select", "generator-select"],
+    async ask(type, config) {
+      const {
+        name: _name,
+        message,
+        default: defaultValue,
+        choices,
+        loop,
+        pageSize,
+        validate,
+        theme,
+        ...rest
+      } = config;
+      if (choices === void 0) {
+        throw new Error('Prompt type "select" requires a "choices" field.');
+      }
+      if (validate !== void 0) {
+        throw new Error('Prompt type "select" does not support "validate".');
+      }
+      const unsupportedKeys = Object.keys(rest);
+      if (unsupportedKeys.length > 0) {
+        throw new Error(
+          `Prompt type "select" does not support: ${unsupportedKeys.join(", ")}. Supported fields are: message, choices, default, pageSize, loop, theme.`
+        );
+      }
+      if (pageSize !== void 0 && (typeof pageSize !== "number" || Number.isNaN(pageSize))) {
+        throw new Error(
+          'Prompt type "select" expects "pageSize" to be a number.'
+        );
+      }
+      if (loop !== void 0 && typeof loop !== "boolean") {
+        throw new Error('Prompt type "select" expects "loop" to be a boolean.');
+      }
+      return selectFn({
+        message: String(message ?? ""),
+        choices,
+        ...defaultValue !== void 0 && { default: defaultValue },
+        ...pageSize !== void 0 && { pageSize },
+        ...loop !== void 0 && { loop },
+        ...theme !== void 0 && { theme }
+      });
+    }
+  };
+}
+var selectPromptHandler = createSelectHandler();
+
+// src/prompts/rawlistPrompt.ts
+import { rawlist } from "@inquirer/prompts";
+var rawlistPromptHandler = {
+  types: ["rawlist"],
+  async ask(_type, config) {
+    const {
+      name: _name,
+      message,
+      choices,
+      default: defaultValue,
+      loop,
+      theme,
+      ...rest
+    } = config;
+    if (choices === void 0) {
+      throw new Error('Prompt type "rawlist" requires a "choices" field.');
+    }
+    const unsupportedKeys = Object.keys(rest);
+    if (unsupportedKeys.length > 0) {
+      throw new Error(
+        `Prompt type "rawlist" does not support: ${unsupportedKeys.join(", ")}. Supported fields are: message, choices, default, loop, theme.`
+      );
+    }
+    if (loop !== void 0 && typeof loop !== "boolean") {
+      throw new Error('Prompt type "rawlist" expects "loop" to be a boolean.');
+    }
+    const runRawlist = rawlist;
+    return runRawlist({
+      message: String(message ?? ""),
+      choices,
+      ...defaultValue !== void 0 && { default: defaultValue },
+      ...loop !== void 0 && { loop },
+      ...theme !== void 0 && { theme }
+    });
+  }
+};
+
+// src/prompts/expandPrompt.ts
+import { expand } from "@inquirer/prompts";
+var expandPromptHandler = {
+  types: ["expand"],
+  async ask(_type, config) {
+    const {
+      name: _name,
+      message,
+      choices,
+      default: defaultValue,
+      expanded,
+      theme,
+      ...rest
+    } = config;
+    if (choices === void 0) {
+      throw new Error('Prompt type "expand" requires a "choices" field.');
+    }
+    const unsupportedKeys = Object.keys(rest);
+    if (unsupportedKeys.length > 0) {
+      throw new Error(
+        `Prompt type "expand" does not support: ${unsupportedKeys.join(", ")}. Supported fields are: message, choices, default, expanded, theme.`
+      );
+    }
+    if (expanded !== void 0 && typeof expanded !== "boolean") {
+      throw new Error('Prompt type "expand" expects "expanded" to be a boolean.');
+    }
+    if (defaultValue !== void 0 && typeof defaultValue !== "string") {
+      throw new Error('Prompt type "expand" expects "default" to be a string key.');
+    }
+    const runExpand = expand;
+    return runExpand({
+      message: String(message ?? ""),
+      choices,
+      ...defaultValue !== void 0 && { default: defaultValue },
+      ...expanded !== void 0 && { expanded },
+      ...theme !== void 0 && { theme }
+    });
+  }
+};
+
+// src/prompts/searchPrompt.ts
+import { search } from "@inquirer/prompts";
+function createSearchHandler(fn) {
+  const searchFn = fn ?? search;
+  return {
+    types: ["search"],
+    async ask(_type, config) {
+      const {
+        name: _name,
+        message,
+        source,
+        pageSize,
+        default: defaultValue,
+        validate,
+        theme,
+        ...rest
+      } = config;
+      if (typeof source !== "function") {
+        throw new Error('Prompt type "search" requires a "source" function.');
+      }
+      const unsupportedKeys = Object.keys(rest);
+      if (unsupportedKeys.length > 0) {
+        throw new Error(
+          `Prompt type "search" does not support: ${unsupportedKeys.join(", ")}. Supported fields are: message, source, pageSize, default, validate, theme.`
+        );
+      }
+      if (pageSize !== void 0 && (typeof pageSize !== "number" || Number.isNaN(pageSize))) {
+        throw new Error('Prompt type "search" expects "pageSize" to be a number.');
+      }
+      if (validate !== void 0 && typeof validate !== "function") {
+        throw new Error('Prompt type "search" expects "validate" to be a function.');
+      }
+      return searchFn({
+        message: String(message ?? ""),
+        source,
+        ...pageSize !== void 0 && { pageSize },
+        ...defaultValue !== void 0 && { default: defaultValue },
+        ...validate !== void 0 && {
+          validate
+        },
+        ...theme !== void 0 && { theme }
+      });
+    }
+  };
+}
+var searchPromptHandler = createSearchHandler();
+
+// src/prompts/checkboxPrompt.ts
+import { checkbox } from "@inquirer/prompts";
+function createCheckboxHandler(fn) {
+  const checkboxFn = fn ?? checkbox;
+  return {
+    types: ["checkbox"],
+    async ask(_type, config) {
+      const {
+        name: _name,
+        message,
+        default: defaultValue,
+        choices,
+        pageSize,
+        loop,
+        required,
+        shortcuts,
+        validate,
+        ...rest
+      } = config;
+      if (choices === void 0) {
+        throw new Error('Prompt type "checkbox" requires a "choices" field.');
+      }
+      if (defaultValue !== void 0) {
+        throw new Error('Prompt type "checkbox" does not support "default". Use choice.checked instead.');
+      }
+      return checkboxFn({
+        message: String(message ?? ""),
+        choices,
+        ...pageSize !== void 0 && { pageSize: Number(pageSize) },
+        ...loop !== void 0 && { loop: Boolean(loop) },
+        ...validate !== void 0 && {
+          validate
+        },
+        ...required !== void 0 && { required: Boolean(required) },
+        ...shortcuts !== void 0 && { shortcuts },
+        ...rest
+      });
+    }
+  };
+}
+var checkboxPromptHandler = createCheckboxHandler();
+
+// src/prompts/editorPrompt.ts
+import { editor } from "@inquirer/prompts";
+function createEditorHandler(fn) {
+  const editorFn = fn ?? editor;
+  return {
+    types: ["editor"],
+    async ask(_type, config) {
+      const {
+        name: _name,
+        message,
+        default: defaultValue,
+        validate,
+        postfix,
+        waitForUserInput,
+        file,
+        theme,
+        ...rest
+      } = config;
+      const unsupportedKeys = Object.keys(rest);
+      if (unsupportedKeys.length > 0) {
+        throw new Error(
+          `Prompt type "editor" does not support: ${unsupportedKeys.join(", ")}. Supported fields are: message, default, postfix, waitForUserInput, file, validate, theme.`
+        );
+      }
+      if (defaultValue !== void 0 && typeof defaultValue !== "string") {
+        throw new Error('Prompt type "editor" expects "default" to be a string.');
+      }
+      if (postfix !== void 0 && typeof postfix !== "string") {
+        throw new Error('Prompt type "editor" expects "postfix" to be a string.');
+      }
+      if (waitForUserInput !== void 0 && typeof waitForUserInput !== "boolean") {
+        throw new Error('Prompt type "editor" expects "waitForUserInput" to be a boolean.');
+      }
+      if (file !== void 0 && (typeof file !== "object" || file === null)) {
+        throw new Error('Prompt type "editor" expects "file" to be an object.');
+      }
+      if (validate !== void 0 && typeof validate !== "function") {
+        throw new Error('Prompt type "editor" expects "validate" to be a function.');
+      }
+      return editorFn({
+        message: String(message ?? ""),
+        ...defaultValue !== void 0 && { default: String(defaultValue) },
+        ...validate !== void 0 && {
+          validate
+        },
+        ...postfix !== void 0 && { postfix: String(postfix) },
+        ...waitForUserInput !== void 0 && { waitForUserInput },
+        ...file !== void 0 && { file },
+        ...theme !== void 0 && { theme }
+      });
+    }
+  };
+}
+var editorPromptHandler = createEditorHandler();
+
+// src/prompts/passwordPrompt.ts
+import { password } from "@inquirer/prompts";
+function createPasswordHandler(fn) {
+  const passwordFn = fn ?? password;
+  return {
+    types: ["password"],
+    async ask(_type, config) {
+      const {
+        name: _name,
+        message,
+        validate,
+        mask,
+        theme,
+        ...rest
+      } = config;
+      const unsupportedKeys = Object.keys(rest);
+      if (unsupportedKeys.length > 0) {
+        throw new Error(
+          `Prompt type "password" does not support: ${unsupportedKeys.join(", ")}. Supported fields are: message, mask, validate, theme.`
+        );
+      }
+      if (mask !== void 0 && typeof mask !== "boolean" && typeof mask !== "string") {
+        throw new Error('Prompt type "password" expects "mask" to be a boolean or string.');
+      }
+      if (validate !== void 0 && typeof validate !== "function") {
+        throw new Error('Prompt type "password" expects "validate" to be a function.');
+      }
+      return passwordFn({
+        message: String(message ?? ""),
+        ...validate !== void 0 && {
+          validate
+        },
+        ...mask !== void 0 && { mask },
+        ...theme !== void 0 && { theme }
+      });
+    }
+  };
+}
+var passwordPromptHandler = createPasswordHandler();
+
+// src/prompts/registerBuiltins.ts
+var builtInPromptHandlers = [
+  inputPromptHandler,
+  numberPromptHandler,
+  confirmPromptHandler,
+  selectPromptHandler,
+  rawlistPromptHandler,
+  expandPromptHandler,
+  searchPromptHandler,
+  checkboxPromptHandler,
+  editorPromptHandler,
+  passwordPromptHandler
+];
+function registerBuiltInPromptHandlers(registry) {
+  for (const handler of builtInPromptHandlers) {
+    registry.register(handler);
+  }
+}
+
+// src/prompts/themeSelector.ts
+var BUILT_IN_PROMPT_THEME_SELECTORS = {
+  common: {
+    prefix: true,
+    spinner: true,
+    style: [
+      "answer",
+      "message",
+      "error",
+      "defaultAnswer",
+      "help",
+      "highlight",
+      "key"
+    ]
+  },
+  input: {
+    prefix: true,
+    spinner: true,
+    validationFailureMode: true,
+    style: ["answer", "message", "error", "defaultAnswer"]
+  },
+  select: {
+    prefix: true,
+    spinner: true,
+    indexMode: true,
+    style: [
+      "answer",
+      "message",
+      "error",
+      "help",
+      "highlight",
+      "description",
+      "disabled",
+      "keysHelpTip"
+    ],
+    icon: ["cursor"],
+    i18n: true,
+    keybindings: true
+  },
+  list: { baseSelector: "select" },
+  "generator-select": { baseSelector: "select" },
+  checkbox: {
+    prefix: true,
+    spinner: true,
+    style: [
+      "answer",
+      "message",
+      "error",
+      "defaultAnswer",
+      "help",
+      "highlight",
+      "key",
+      "disabled",
+      "disabledChoice",
+      "description",
+      "renderSelectedChoices",
+      "keysHelpTip"
+    ],
+    icon: [
+      "checked",
+      "unchecked",
+      "cursor",
+      "disabledChecked",
+      "disabledUnchecked"
+    ],
+    i18n: true,
+    keybindings: true
+  },
+  confirm: {
+    prefix: true,
+    spinner: true,
+    style: ["answer", "message", "defaultAnswer"]
+  },
+  search: {
+    prefix: true,
+    spinner: true,
+    style: [
+      "answer",
+      "message",
+      "error",
+      "help",
+      "highlight",
+      "description",
+      "disabled",
+      "searchTerm",
+      "keysHelpTip"
+    ],
+    icon: ["cursor"]
+  },
+  password: {
+    prefix: true,
+    spinner: true,
+    style: ["answer", "message", "error", "help", "maskedText"]
+  },
+  expand: {
+    prefix: true,
+    spinner: true,
+    style: ["answer", "message", "error", "defaultAnswer", "highlight"]
+  },
+  editor: {
+    prefix: true,
+    spinner: true,
+    validationFailureMode: true,
+    style: ["message", "error", "help", "key", "waitingMessage"]
+  },
+  number: {
+    prefix: true,
+    spinner: true,
+    style: ["answer", "message", "error", "defaultAnswer"]
+  },
+  rawlist: {
+    prefix: true,
+    spinner: true,
+    style: ["answer", "message", "error", "highlight", "description"]
+  }
+};
+var PromptThemeSelectorRegistry = class {
+  constructor() {
+    this.selectors = /* @__PURE__ */ new Map();
+    this.defaultSelectorName = "common";
+    for (const [type, selector] of Object.entries(
+      BUILT_IN_PROMPT_THEME_SELECTORS
+    )) {
+      this.selectors.set(type, cloneSelector(selector));
+    }
+  }
+  register(type, selector) {
+    this.selectors.set(type, cloneSelector(selector));
+  }
+  resolve(type) {
+    return this.selectors.get(type);
+  }
+  registerWithDefault(type, selector) {
+    this.register(type, {
+      baseSelector: this.defaultSelectorName,
+      ...selector ?? {}
+    });
+  }
+  resolveTheme(type, theme) {
+    const selector = this.resolve(type);
+    if (!selector) {
+      return this.resolveTheme(this.defaultSelectorName, theme);
+    }
+    const resolved = this.expandSelector(selector, /* @__PURE__ */ new Set());
+    const source = theme;
+    const output = {};
+    for (const [field, spec] of Object.entries(resolved)) {
+      if (!Object.prototype.hasOwnProperty.call(source, field)) continue;
+      if (spec === true) {
+        output[field] = source[field];
+      } else {
+        const sourceObj = source[field];
+        if (sourceObj === null || typeof sourceObj !== "object" || Array.isArray(sourceObj)) {
+          continue;
+        }
+        const filtered = {};
+        for (const subField of spec) {
+          if (Object.prototype.hasOwnProperty.call(sourceObj, subField)) {
+            filtered[subField] = sourceObj[subField];
+          }
+        }
+        if (Object.keys(filtered).length > 0) {
+          output[field] = filtered;
+        }
+      }
+    }
+    return output;
+  }
+  expandSelector(selector, visited) {
+    const result = {};
+    if (selector.baseSelector) {
+      if (visited.has(selector.baseSelector)) {
+        throw new Error(
+          `Circular prompt theme selector inheritance detected for "${selector.baseSelector}".`
+        );
+      }
+      const base = this.selectors.get(selector.baseSelector);
+      if (!base) {
+        throw new Error(
+          `Unknown prompt theme selector base "${selector.baseSelector}".`
+        );
+      }
+      visited.add(selector.baseSelector);
+      const expandedBase = this.expandSelector(base, visited);
+      Object.assign(result, expandedBase);
+      visited.delete(selector.baseSelector);
+    }
+    for (const [field, spec] of Object.entries(selector)) {
+      if (field === "baseSelector") continue;
+      const typedSpec = spec;
+      if (typedSpec === true) {
+        result[field] = true;
+      } else if (Array.isArray(typedSpec)) {
+        const existing = result[field];
+        if (Array.isArray(existing)) {
+          const merged = /* @__PURE__ */ new Set([...existing, ...typedSpec]);
+          result[field] = [...merged];
+        } else {
+          result[field] = [...typedSpec];
+        }
+      }
+    }
+    return result;
+  }
+};
+function createPromptThemeSelector(options) {
+  const { selector, ...fields } = options;
+  return {
+    ...selector !== void 0 ? { baseSelector: selector } : {},
+    ...fields
+  };
+}
+function cloneSelector(selector) {
+  const cloned = {};
+  if (selector.baseSelector !== void 0) {
+    cloned.baseSelector = selector.baseSelector;
+  }
+  for (const [field, spec] of Object.entries(selector)) {
+    if (field === "baseSelector") continue;
+    cloned[field] = Array.isArray(spec) ? [...spec] : spec;
+  }
+  return cloned;
+}
+
+// src/prompts/customPrompt.ts
+function registerCustomPrompt(promptTypes, name, prompt) {
+  if (!prompt) {
+    throw new Error(`registerPrompt("${name}", prompt) requires a prompt function.`);
+  }
+  promptTypes.set(name, prompt);
+}
+function getCustomPrompt(promptTypes, name) {
+  return promptTypes.get(name);
+}
+function listCustomPromptTypes(promptTypes) {
+  return Array.from(promptTypes.keys());
+}
+function askCustomPrompt(prompt, config) {
+  const { name: _name, ...rest } = config;
+  return Promise.resolve(prompt(rest));
+}
+
+// src/theme.ts
+import { styleText } from "util";
+
+// ../../node_modules/is-unicode-supported/index.js
+import process2 from "process";
+function isUnicodeSupported() {
+  const { env } = process2;
+  const { TERM, TERM_PROGRAM } = env;
+  if (process2.platform !== "win32") {
+    return TERM !== "linux";
+  }
+  return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+
+// ../../node_modules/figures/index.js
+var common = {
+  circleQuestionMark: "(?)",
+  questionMarkPrefix: "(?)",
+  square: "\u2588",
+  squareDarkShade: "\u2593",
+  squareMediumShade: "\u2592",
+  squareLightShade: "\u2591",
+  squareTop: "\u2580",
+  squareBottom: "\u2584",
+  squareLeft: "\u258C",
+  squareRight: "\u2590",
+  squareCenter: "\u25A0",
+  bullet: "\u25CF",
+  dot: "\u2024",
+  ellipsis: "\u2026",
+  pointerSmall: "\u203A",
+  triangleUp: "\u25B2",
+  triangleUpSmall: "\u25B4",
+  triangleDown: "\u25BC",
+  triangleDownSmall: "\u25BE",
+  triangleLeftSmall: "\u25C2",
+  triangleRightSmall: "\u25B8",
+  home: "\u2302",
+  heart: "\u2665",
+  musicNote: "\u266A",
+  musicNoteBeamed: "\u266B",
+  arrowUp: "\u2191",
+  arrowDown: "\u2193",
+  arrowLeft: "\u2190",
+  arrowRight: "\u2192",
+  arrowLeftRight: "\u2194",
+  arrowUpDown: "\u2195",
+  almostEqual: "\u2248",
+  notEqual: "\u2260",
+  lessOrEqual: "\u2264",
+  greaterOrEqual: "\u2265",
+  identical: "\u2261",
+  infinity: "\u221E",
+  subscriptZero: "\u2080",
+  subscriptOne: "\u2081",
+  subscriptTwo: "\u2082",
+  subscriptThree: "\u2083",
+  subscriptFour: "\u2084",
+  subscriptFive: "\u2085",
+  subscriptSix: "\u2086",
+  subscriptSeven: "\u2087",
+  subscriptEight: "\u2088",
+  subscriptNine: "\u2089",
+  oneHalf: "\xBD",
+  oneThird: "\u2153",
+  oneQuarter: "\xBC",
+  oneFifth: "\u2155",
+  oneSixth: "\u2159",
+  oneEighth: "\u215B",
+  twoThirds: "\u2154",
+  twoFifths: "\u2156",
+  threeQuarters: "\xBE",
+  threeFifths: "\u2157",
+  threeEighths: "\u215C",
+  fourFifths: "\u2158",
+  fiveSixths: "\u215A",
+  fiveEighths: "\u215D",
+  sevenEighths: "\u215E",
+  line: "\u2500",
+  lineBold: "\u2501",
+  lineDouble: "\u2550",
+  lineDashed0: "\u2504",
+  lineDashed1: "\u2505",
+  lineDashed2: "\u2508",
+  lineDashed3: "\u2509",
+  lineDashed4: "\u254C",
+  lineDashed5: "\u254D",
+  lineDashed6: "\u2574",
+  lineDashed7: "\u2576",
+  lineDashed8: "\u2578",
+  lineDashed9: "\u257A",
+  lineDashed10: "\u257C",
+  lineDashed11: "\u257E",
+  lineDashed12: "\u2212",
+  lineDashed13: "\u2013",
+  lineDashed14: "\u2010",
+  lineDashed15: "\u2043",
+  lineVertical: "\u2502",
+  lineVerticalBold: "\u2503",
+  lineVerticalDouble: "\u2551",
+  lineVerticalDashed0: "\u2506",
+  lineVerticalDashed1: "\u2507",
+  lineVerticalDashed2: "\u250A",
+  lineVerticalDashed3: "\u250B",
+  lineVerticalDashed4: "\u254E",
+  lineVerticalDashed5: "\u254F",
+  lineVerticalDashed6: "\u2575",
+  lineVerticalDashed7: "\u2577",
+  lineVerticalDashed8: "\u2579",
+  lineVerticalDashed9: "\u257B",
+  lineVerticalDashed10: "\u257D",
+  lineVerticalDashed11: "\u257F",
+  lineDownLeft: "\u2510",
+  lineDownLeftArc: "\u256E",
+  lineDownBoldLeftBold: "\u2513",
+  lineDownBoldLeft: "\u2512",
+  lineDownLeftBold: "\u2511",
+  lineDownDoubleLeftDouble: "\u2557",
+  lineDownDoubleLeft: "\u2556",
+  lineDownLeftDouble: "\u2555",
+  lineDownRight: "\u250C",
+  lineDownRightArc: "\u256D",
+  lineDownBoldRightBold: "\u250F",
+  lineDownBoldRight: "\u250E",
+  lineDownRightBold: "\u250D",
+  lineDownDoubleRightDouble: "\u2554",
+  lineDownDoubleRight: "\u2553",
+  lineDownRightDouble: "\u2552",
+  lineUpLeft: "\u2518",
+  lineUpLeftArc: "\u256F",
+  lineUpBoldLeftBold: "\u251B",
+  lineUpBoldLeft: "\u251A",
+  lineUpLeftBold: "\u2519",
+  lineUpDoubleLeftDouble: "\u255D",
+  lineUpDoubleLeft: "\u255C",
+  lineUpLeftDouble: "\u255B",
+  lineUpRight: "\u2514",
+  lineUpRightArc: "\u2570",
+  lineUpBoldRightBold: "\u2517",
+  lineUpBoldRight: "\u2516",
+  lineUpRightBold: "\u2515",
+  lineUpDoubleRightDouble: "\u255A",
+  lineUpDoubleRight: "\u2559",
+  lineUpRightDouble: "\u2558",
+  lineUpDownLeft: "\u2524",
+  lineUpBoldDownBoldLeftBold: "\u252B",
+  lineUpBoldDownBoldLeft: "\u2528",
+  lineUpDownLeftBold: "\u2525",
+  lineUpBoldDownLeftBold: "\u2529",
+  lineUpDownBoldLeftBold: "\u252A",
+  lineUpDownBoldLeft: "\u2527",
+  lineUpBoldDownLeft: "\u2526",
+  lineUpDoubleDownDoubleLeftDouble: "\u2563",
+  lineUpDoubleDownDoubleLeft: "\u2562",
+  lineUpDownLeftDouble: "\u2561",
+  lineUpDownRight: "\u251C",
+  lineUpBoldDownBoldRightBold: "\u2523",
+  lineUpBoldDownBoldRight: "\u2520",
+  lineUpDownRightBold: "\u251D",
+  lineUpBoldDownRightBold: "\u2521",
+  lineUpDownBoldRightBold: "\u2522",
+  lineUpDownBoldRight: "\u251F",
+  lineUpBoldDownRight: "\u251E",
+  lineUpDoubleDownDoubleRightDouble: "\u2560",
+  lineUpDoubleDownDoubleRight: "\u255F",
+  lineUpDownRightDouble: "\u255E",
+  lineDownLeftRight: "\u252C",
+  lineDownBoldLeftBoldRightBold: "\u2533",
+  lineDownLeftBoldRightBold: "\u252F",
+  lineDownBoldLeftRight: "\u2530",
+  lineDownBoldLeftBoldRight: "\u2531",
+  lineDownBoldLeftRightBold: "\u2532",
+  lineDownLeftRightBold: "\u252E",
+  lineDownLeftBoldRight: "\u252D",
+  lineDownDoubleLeftDoubleRightDouble: "\u2566",
+  lineDownDoubleLeftRight: "\u2565",
+  lineDownLeftDoubleRightDouble: "\u2564",
+  lineUpLeftRight: "\u2534",
+  lineUpBoldLeftBoldRightBold: "\u253B",
+  lineUpLeftBoldRightBold: "\u2537",
+  lineUpBoldLeftRight: "\u2538",
+  lineUpBoldLeftBoldRight: "\u2539",
+  lineUpBoldLeftRightBold: "\u253A",
+  lineUpLeftRightBold: "\u2536",
+  lineUpLeftBoldRight: "\u2535",
+  lineUpDoubleLeftDoubleRightDouble: "\u2569",
+  lineUpDoubleLeftRight: "\u2568",
+  lineUpLeftDoubleRightDouble: "\u2567",
+  lineUpDownLeftRight: "\u253C",
+  lineUpBoldDownBoldLeftBoldRightBold: "\u254B",
+  lineUpDownBoldLeftBoldRightBold: "\u2548",
+  lineUpBoldDownLeftBoldRightBold: "\u2547",
+  lineUpBoldDownBoldLeftRightBold: "\u254A",
+  lineUpBoldDownBoldLeftBoldRight: "\u2549",
+  lineUpBoldDownLeftRight: "\u2540",
+  lineUpDownBoldLeftRight: "\u2541",
+  lineUpDownLeftBoldRight: "\u253D",
+  lineUpDownLeftRightBold: "\u253E",
+  lineUpBoldDownBoldLeftRight: "\u2542",
+  lineUpDownLeftBoldRightBold: "\u253F",
+  lineUpBoldDownLeftBoldRight: "\u2543",
+  lineUpBoldDownLeftRightBold: "\u2544",
+  lineUpDownBoldLeftBoldRight: "\u2545",
+  lineUpDownBoldLeftRightBold: "\u2546",
+  lineUpDoubleDownDoubleLeftDoubleRightDouble: "\u256C",
+  lineUpDoubleDownDoubleLeftRight: "\u256B",
+  lineUpDownLeftDoubleRightDouble: "\u256A",
+  lineCross: "\u2573",
+  lineBackslash: "\u2572",
+  lineSlash: "\u2571"
+};
+var specialMainSymbols = {
+  tick: "\u2714",
+  info: "\u2139",
+  warning: "\u26A0",
+  cross: "\u2718",
+  squareSmall: "\u25FB",
+  squareSmallFilled: "\u25FC",
+  circle: "\u25EF",
+  circleFilled: "\u25C9",
+  circleDotted: "\u25CC",
+  circleDouble: "\u25CE",
+  circleCircle: "\u24DE",
+  circleCross: "\u24E7",
+  circlePipe: "\u24BE",
+  radioOn: "\u25C9",
+  radioOff: "\u25EF",
+  checkboxOn: "\u2612",
+  checkboxOff: "\u2610",
+  checkboxCircleOn: "\u24E7",
+  checkboxCircleOff: "\u24BE",
+  pointer: "\u276F",
+  triangleUpOutline: "\u25B3",
+  triangleLeft: "\u25C0",
+  triangleRight: "\u25B6",
+  lozenge: "\u25C6",
+  lozengeOutline: "\u25C7",
+  hamburger: "\u2630",
+  smiley: "\u32E1",
+  mustache: "\u0DF4",
+  star: "\u2605",
+  play: "\u25B6",
+  nodejs: "\u2B22",
+  oneSeventh: "\u2150",
+  oneNinth: "\u2151",
+  oneTenth: "\u2152"
+};
+var specialFallbackSymbols = {
+  tick: "\u221A",
+  info: "i",
+  warning: "\u203C",
+  cross: "\xD7",
+  squareSmall: "\u25A1",
+  squareSmallFilled: "\u25A0",
+  circle: "( )",
+  circleFilled: "(*)",
+  circleDotted: "( )",
+  circleDouble: "( )",
+  circleCircle: "(\u25CB)",
+  circleCross: "(\xD7)",
+  circlePipe: "(\u2502)",
+  radioOn: "(*)",
+  radioOff: "( )",
+  checkboxOn: "[\xD7]",
+  checkboxOff: "[ ]",
+  checkboxCircleOn: "(\xD7)",
+  checkboxCircleOff: "( )",
+  pointer: ">",
+  triangleUpOutline: "\u2206",
+  triangleLeft: "\u25C4",
+  triangleRight: "\u25BA",
+  lozenge: "\u2666",
+  lozengeOutline: "\u25CA",
+  hamburger: "\u2261",
+  smiley: "\u263A",
+  mustache: "\u250C\u2500\u2510",
+  star: "\u2736",
+  play: "\u25BA",
+  nodejs: "\u2666",
+  oneSeventh: "1/7",
+  oneNinth: "1/9",
+  oneTenth: "1/10"
+};
+var mainSymbols = { ...common, ...specialMainSymbols };
+var fallbackSymbols = { ...common, ...specialFallbackSymbols };
+var shouldUseMain = isUnicodeSupported();
+var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+var figures_default = figures;
+var replacements = Object.entries(specialMainSymbols);
+
+// src/theme.ts
+var BUILT_IN_PROMPT_TYPES = [
+  "input",
+  "select",
+  "generator-select",
+  "list",
+  "checkbox",
+  "confirm",
+  "search",
+  "password",
+  "expand",
+  "editor",
+  "number",
+  "rawlist"
+];
+var defaultTheme = {
+  icon: {
+    idle: styleText("blue", "?"),
+    done: styleText("green", figures_default.tick),
+    cursor: figures_default.pointer,
+    checked: styleText("green", figures_default.circleFilled),
+    unchecked: figures_default.circle,
+    disabledChecked: styleText("green", figures_default.circleDouble),
+    disabledUnchecked: "-"
+  },
+  prefix: {
+    idle: styleText("blue", "?"),
+    done: styleText("green", figures_default.tick)
+  },
+  spinner: {
+    interval: 80,
+    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"].map(
+      (frame) => styleText("yellow", frame)
+    )
+  },
+  style: {
+    answer: (text) => styleText("cyan", text),
+    message: (text) => styleText("bold", text),
+    error: (text) => styleText("red", `> ${text}`),
+    defaultAnswer: (text) => styleText("dim", `(${text})`),
+    help: (text) => styleText("dim", text),
+    highlight: (text) => styleText("cyan", text),
+    description: (text) => styleText("cyan", text),
+    disabled: (text) => styleText("dim", text),
+    disabledChoice: (text) => styleText("dim", `- ${text}`),
+    searchTerm: (text) => styleText("cyan", text),
+    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+    keysHelpTip: (keys) => keys.map(
+      ([key, action]) => `${styleText("bold", key)} ${styleText("dim", action)}`
+    ).join(styleText("dim", " \u2022 ")),
+    key: (text) => styleText("cyan", styleText("bold", `<${text}>`)),
+    maskedText: "[input is masked]",
+    waitingMessage: (enterKey) => `Press ${enterKey} to launch your preferred editor.`
+  },
+  validationFailureMode: "keep",
+  indexMode: "hidden",
+  i18n: {
+    disabledError: "This option is disabled and cannot be selected."
+  },
+  keybindings: [],
+  plopNext: {
+    menuTitle: (text) => styleText(["bold", "underline"], text),
+    welcome: (text) => styleText("dim", text),
+    generatorMenu: {
+      title: (text) => styleText("bold", text),
+      description: (text) => styleText("dim", text)
+    },
+    actionLog: {
+      success: (text) => styleText("green", text),
+      error: (text) => styleText("red", text),
+      warning: (text) => styleText("yellow", text),
+      skipped: (text) => styleText("yellow", text),
+      info: (text) => styleText("dim", text)
+    },
+    errors: {
+      prefix: {
+        error: "\u2716",
+        warning: "\u26A0"
+      },
+      error: (text) => styleText("red", text),
+      warning: (text) => styleText("yellow", text)
+    }
+  }
+};
+var PROMPT_TYPE_THEMES = {
+  /**
+   * Checkbox-specific defaults.
+   * - Different disabledError message ("toggled" instead of "selected")
+   */
+  checkbox: {
+    i18n: {
+      disabledError: "This option is disabled and cannot be toggled."
+    }
+  },
+  /**
+   * Search-specific defaults.
+   * - Disabled items are prefixed with "- " for visibility
+   */
+  search: {
+    style: {
+      disabled: (text) => styleText("dim", `- ${text}`)
+    }
+  }
+};
+
+// src/PlopNextCore.ts
+var requireModule = createRequire(import.meta.url);
+var MODULE_THEME_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".cjs", ".ts", ".cts"]);
+var PlopNextCore = class {
+  constructor() {
+    this.generators = /* @__PURE__ */ new Map();
+    this.generatorEntries = [];
+    this.actionTypes = /* @__PURE__ */ new Map();
+    /** Legacy custom prompt renderers (registered via addPrompt / setPrompt). */
+    this.promptTypes = /* @__PURE__ */ new Map();
+    /** Typed prompt handlers registered via registerPrompt(handler). */
+    this.promptHandlerRegistry = new PromptHandlerRegistry();
+    this.promptThemeSelectorRegistry = new PromptThemeSelectorRegistry();
+    this.translatableFieldRules = /* @__PURE__ */ new Map();
+    this.showWelcomeMessageFlag = false;
+    this.showTitleFlag = true;
+    this.generatorPageSize = 7;
+    this.destBasePath = process.cwd();
+    this.defaultInclude = {};
+    this.theme = {};
+    this.registerBuiltInHelpers();
+    registerBuiltInPromptHandlers(this.promptHandlerRegistry);
+  }
+  // ── Generators ────────────────────────────────────────────────────
+  /**
+   * Register a named generator.
+   *
+   * @example
+   * plopNext.registerGenerator("component", { prompts: [...], actions: [...] });
+   */
+  registerGenerator(name, config) {
+    if (!this.generators.has(name)) {
+      this.generatorEntries.push({ kind: "generator", name });
+    }
+    this.generators.set(name, config);
+    return this;
+  }
+  addSeparator(text) {
+    this.generatorEntries.push({ kind: "separator", text });
+    return this;
+  }
+  // Backward-compatible alias.
+  setGenerator(name, config) {
+    return this.registerGenerator(name, config);
+  }
+  registerHelper(name, helper) {
+    Handlebars.registerHelper(name, helper);
+    return this;
+  }
+  // Backward-compatible alias.
+  setHelper(name, helper) {
+    return this.registerHelper(name, helper);
+  }
+  registerPartial(name, partial) {
+    Handlebars.registerPartial(name, partial);
+    return this;
+  }
+  // Backward-compatible alias.
+  setPartial(name, partial) {
+    return this.registerPartial(name, partial);
+  }
+  registerActionType(name, actionType) {
+    this.actionTypes.set(name, actionType);
+    return this;
+  }
+  // Backward-compatible alias.
+  setActionType(name, actionType) {
+    return this.registerActionType(name, actionType);
+  }
+  registerPrompt(nameOrHandler, prompt, options) {
+    if (typeof nameOrHandler === "string") {
+      registerCustomPrompt(this.promptTypes, nameOrHandler, prompt);
+      const themeOptions = options?.theme;
+      if (themeOptions && Object.keys(themeOptions).length > 0) {
+        this.promptThemeSelectorRegistry.registerWithDefault(
+          nameOrHandler,
+          createPromptThemeSelector(themeOptions)
+        );
+      } else {
+        this.promptThemeSelectorRegistry.registerWithDefault(nameOrHandler);
+      }
+      if (options?.translatableFields && options.translatableFields.length > 0) {
+        const existing = this.translatableFieldRules.get(nameOrHandler) ?? [];
+        const merged = [...existing, ...options.translatableFields];
+        this.translatableFieldRules.set(nameOrHandler, merged);
+        this.i18nAdapter?.registerTranslatableFields?.(
+          nameOrHandler,
+          options.translatableFields
+        );
+      }
+      return this;
+    }
+    this.promptHandlerRegistry.register(nameOrHandler);
+    return this;
+  }
+  // Backward-compatible alias.
+  setPrompt(name, prompt) {
+    return this.registerPrompt(name, prompt);
+  }
+  getPrompt(name) {
+    return getCustomPrompt(this.promptTypes, name);
+  }
+  getPromptList() {
+    return listCustomPromptTypes(this.promptTypes);
+  }
+  /** List the type strings that have a registered PromptHandler. */
+  getPromptHandlerTypes() {
+    return this.promptHandlerRegistry.getRegisteredTypes();
+  }
+  /**
+   * Dispatch a prompt to the appropriate handler.
+   *
+   * Resolution order:
+   * 1. Legacy PromptRenderer registered via `addPrompt()` / `setPrompt()` — highest priority.
+   * 2. PromptHandler registered via `registerPrompt(handler)` for the exact type.
+   * 3. PromptHandler registered for "input" as fallback.
+   *
+   * @param type   Prompt type string (e.g. "input", "list", "datepicker").
+   * @param config All prompt fields minus plop-next-only keys (type/name/filter/when/askAnswered).
+   */
+  async askPrompt(type, config) {
+    if (Object.prototype.hasOwnProperty.call(config, "theme")) {
+      throw new Error(
+        `The "theme" prompt field is not supported in plop-next. Use core.setTheme({ ... }) or core.setTheme("./path/to/theme-file") instead.`
+      );
+    }
+    const promptTheme = this.resolvePromptTheme(type);
+    const configWithTheme = promptTheme === void 0 ? config : {
+      ...config,
+      theme: promptTheme
+    };
+    const customFn = this.getPrompt(type);
+    if (customFn) {
+      return askCustomPrompt(customFn, configWithTheme);
+    }
+    return this.promptHandlerRegistry.ask(type, configWithTheme, {
+      allowTheme: true
+    });
+  }
+  setTheme(theme) {
+    const resolvedTheme = this.resolveThemeInput(theme);
+    this.theme = this.cloneTheme(resolvedTheme);
+    return this;
+  }
+  getTheme() {
+    return this.cloneTheme(this.resolveTheme());
+  }
+  resolveThemeInput(theme) {
+    if (typeof theme !== "string") {
+      return theme;
+    }
+    const absolutePath = resolve2(this.destBasePath, theme);
+    if (!existsSync2(absolutePath)) {
+      throw new Error(`Theme file not found: ${absolutePath}`);
+    }
+    const extension = extname(absolutePath).toLowerCase();
+    const parsed = extension === ".json" ? this.parseThemeJsonFile(absolutePath) : this.parseThemeModuleFile(absolutePath, extension);
+    if (!this.isRecord(parsed)) {
+      throw new Error(
+        `Theme file must contain an object at root: ${absolutePath}`
+      );
+    }
+    if (this.looksLikeI18nSource(parsed) && !this.looksLikeThemeSource(parsed)) {
+      throw new Error(
+        `Invalid theme file at ${absolutePath}: looks like locales/texts content. Use registerLocale(s) or registerTexts for translation files.`
+      );
+    }
+    if (!this.looksLikeThemeSource(parsed)) {
+      throw new Error(
+        `Invalid theme file at ${absolutePath}: no theme fields were detected.`
+      );
+    }
+    return parsed;
+  }
+  parseThemeJsonFile(filePath) {
+    try {
+      return JSON.parse(readFileSync(filePath, "utf8"));
+    } catch (error) {
+      throw new Error(
+        `Invalid theme JSON file at ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  parseThemeModuleFile(filePath, extension) {
+    if (!MODULE_THEME_FILE_EXTENSIONS.has(extension)) {
+      throw new Error(
+        `Unsupported theme file extension "${extension || "<none>"}" at ${filePath}. Supported extensions: .json, .js, .cjs, .ts, .cts.`
+      );
+    }
+    let loaded;
+    try {
+      loaded = requireModule(filePath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Unable to load theme module at ${filePath}: ${message}. If this file is ESM-only, import it in your plopfile and pass the object directly to setTheme(...).`
+      );
+    }
+    const unwrapped = this.unwrapModuleDefault(loaded);
+    if (typeof unwrapped === "function") {
+      const resolved = unwrapped();
+      return this.unwrapModuleDefault(resolved);
+    }
+    return unwrapped;
+  }
+  getActionType(name) {
+    return this.actionTypes.get(name);
+  }
+  getActionTypeList() {
+    return Array.from(this.actionTypes.keys());
+  }
+  getHelper(name) {
+    const helpers = Handlebars.helpers;
+    const helper = helpers[name];
+    return typeof helper === "function" ? helper : void 0;
+  }
+  getHelperList() {
+    const helpers = Handlebars.helpers;
+    return Object.keys(helpers).filter(
+      (name) => typeof helpers[name] === "function"
+    );
+  }
+  getPartial(name) {
+    const partials = Handlebars.partials;
+    const partial = partials[name];
+    if (typeof partial === "string") {
+      return partial;
+    }
+    return void 0;
+  }
+  getPartialList() {
+    const partials = Handlebars.partials;
+    return Object.keys(partials);
+  }
+  showWelcomeMessage(show = true) {
+    this.showWelcomeMessageFlag = show;
+    return this;
+  }
+  getWelcomeMessage() {
+    return this.i18nAdapter?.getWelcomeMessage?.() ?? null;
+  }
+  isWelcomeMessageShown() {
+    return this.showWelcomeMessageFlag;
+  }
+  showTitle(show = true) {
+    this.showTitleFlag = show;
+    return this;
+  }
+  isTitleShown() {
+    return this.showTitleFlag;
+  }
+  /**
+   * Set page size used by the generator selection prompt.
+   * Defaults to 7.
+   */
+  setGeneratorPageSize(pageSize) {
+    if (!Number.isInteger(pageSize) || pageSize < 1) {
+      throw new Error(
+        "Generator page size must be an integer greater than or equal to 1."
+      );
+    }
+    this.generatorPageSize = pageSize;
+    return this;
+  }
+  /**
+   * Get page size used by the generator selection prompt.
+   */
+  getGeneratorPageSize() {
+    return this.generatorPageSize;
+  }
+  setI18nAdapter(adapter) {
+    this.i18nAdapter = adapter;
+    return this;
+  }
+  setWarningReporter(reporter) {
+    this.warningReporter = reporter;
+    return this;
+  }
+  reportWarning(warning) {
+    this.warningReporter?.(warning);
+    return this;
+  }
+  clearI18nAdapter() {
+    this.i18nAdapter = void 0;
+    return this;
+  }
+  setPlopfilePath(path) {
+    this.plopfilePath = resolve2(path);
+    this.destBasePath = dirname2(this.plopfilePath);
+    this.pkgCache = void 0;
+    this.pkgCachePath = void 0;
+    return this;
+  }
+  getPlopfilePath() {
+    return this.plopfilePath;
+  }
+  setDestBasePath(path) {
+    this.destBasePath = resolve2(path);
+    return this;
+  }
+  getDestBasePath() {
+    return this.destBasePath;
+  }
+  setDefaultInclude(include) {
+    this.defaultInclude = { ...include };
+    return this;
+  }
+  getDefaultInclude() {
+    return { ...this.defaultInclude };
+  }
+  renderString(template, data) {
+    const compiled = Handlebars.compile(template, { noEscape: true });
+    return compiled(data);
+  }
+  getGenerator(name) {
+    return this.generators.get(name);
+  }
+  getGeneratorList() {
+    const result = [];
+    for (const entry of this.generatorEntries) {
+      if (entry.kind === "separator") {
+        result.push({
+          type: "separator",
+          separator: entry.text ?? ""
+        });
+      } else {
+        const cfg = this.generators.get(entry.name);
+        if (cfg)
+          result.push({ name: entry.name, description: cfg.description });
+      }
+    }
+    return result;
+  }
+  // ── i18n integration ─────────────────────────────────────────────
+  /**
+   * Enable i18n support.
+   *
+   * - `force`: always use this locale.
+   * - `auto` (default): detect locale from process environment,
+   *   then fall back to English.
+   */
+  useI18n(options = { auto: true }) {
+    this.i18nAdapter?.use?.(options);
+    return this;
+  }
+  isI18nEnabled() {
+    return this.i18nAdapter?.isEnabled?.() ?? false;
+  }
+  // ── Text resolution ───────────────────────────────────────────────
+  /**
+   * Resolve the display text for a prompt field.
+   *
+   * When i18n is **disabled**: returns `defaultMessage` as-is.
+   * When i18n is **enabled**: looks up `<generatorName>.<promptName>.<field>`
+   * in the active locale, falls back to English, then to `defaultMessage`.
+   *
+   * @param generatorName  Generator key, e.g. "component"
+   * @param promptName     Prompt name, e.g. "name"
+   * @param field          Field name, e.g. "message"
+   * @param defaultMessage Raw string or function defined inside setGenerator
+   */
+  resolveText(generatorName, promptName, field, defaultMessage, args = []) {
+    if (!this.i18nAdapter) {
+      return defaultMessage;
+    }
+    const key = `${generatorName}.${promptName}.${field}`;
+    const fallback = typeof defaultMessage === "function" ? defaultMessage(...args) : defaultMessage;
+    const resolved = this.i18nAdapter.t(key, args, fallback);
+    return resolved !== key ? resolved : defaultMessage ?? key;
+  }
+  /**
+   * Resolve a built-in core UI text (e.g. "cli.welcome").
+   */
+  t(key, args = [], fallback) {
+    if (!this.i18nAdapter) {
+      return fallback ?? key;
+    }
+    return this.i18nAdapter.t(key, args, fallback);
+  }
+  // ── Locale helpers ────────────────────────────────────────────────
+  /**
+   * Add or override messages for an existing locale.
+   * Available whether or not i18n plugin is loaded.
+   */
+  addTexts(locale, texts) {
+    this.i18nAdapter?.registerTexts?.(locale, texts);
+    return this;
+  }
+  registerText(locale, path, text) {
+    this.i18nAdapter?.registerText?.(locale, path, text);
+    return this;
+  }
+  registerLocale(locale, messages, options = {}) {
+    this.i18nAdapter?.registerLocale?.(locale, messages, options);
+    return this;
+  }
+  registerLocales(locales, options = {}) {
+    this.i18nAdapter?.registerLocales?.(locales, options);
+    return this;
+  }
+  registerTexts(localeOrTexts, maybeTexts) {
+    if (typeof localeOrTexts === "string" && typeof maybeTexts !== "undefined") {
+      this.i18nAdapter?.registerTexts?.(localeOrTexts, maybeTexts);
+      return this;
+    }
+    this.i18nAdapter?.registerTexts?.(
+      localeOrTexts
+    );
+    return this;
+  }
+  setLocale(locale) {
+    this.i18nAdapter?.setLocale?.(locale);
+    return this;
+  }
+  getLocale() {
+    return this.i18nAdapter?.getLocale?.() ?? "en";
+  }
+  hasLocale(locale) {
+    if (locale === "en") {
+      return true;
+    }
+    return this.i18nAdapter?.hasLocale?.(locale) ?? false;
+  }
+  async executeActions(actions, answers, options = {}) {
+    const runner = new ActionRunner(this, {
+      dest: options.dest,
+      force: options.force
+    });
+    const steps = [];
+    let failed = false;
+    for (const action of actions) {
+      try {
+        if (typeof action === "string") {
+          steps.push({
+            type: "comment",
+            status: "success",
+            message: action
+          });
+          continue;
+        }
+        if (typeof action === "function") {
+          const message = await action(answers, { type: "custom" }, this);
+          steps.push({
+            type: "function",
+            status: "success",
+            message: String(message)
+          });
+          continue;
+        }
+        if (action.skip) {
+          const skipResult = await action.skip(answers, action);
+          if (skipResult) {
+            steps.push({
+              type: "skip",
+              status: "success",
+              message: typeof skipResult === "string" ? skipResult : "Skipped",
+              path: typeof action.path === "string" ? action.path : void 0
+            });
+            continue;
+          }
+        }
+        if (this.actionTypes.has(action.type)) {
+          const customAction = this.actionTypes.get(
+            action.type
+          );
+          const message = await customAction(
+            answers,
+            action,
+            this
+          );
+          steps.push({
+            type: action.type,
+            status: "success",
+            message: String(message),
+            path: typeof action.path === "string" ? action.path : void 0
+          });
+          continue;
+        }
+        const result = await runner.run(action.type, action, answers);
+        steps.push({
+          type: result.type,
+          status: "success",
+          message: result.message,
+          path: result.path
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const type = typeof action === "function" ? "function" : typeof action === "string" ? "comment" : action.type;
+        steps.push({ type, status: "error", message });
+        if (typeof action === "object" && action.abortOnFail !== false) {
+          failed = true;
+          break;
+        }
+      }
+    }
+    return { steps, failed };
+  }
+  async resolveActions(actions, answers) {
+    const resolved = typeof actions === "function" ? await actions(answers) : actions;
+    if (!Array.isArray(resolved)) {
+      throw new Error("Generator actions must resolve to an array.");
+    }
+    return resolved;
+  }
+  getActionTypeDisplay(type, showTypeNames = false) {
+    if (showTypeNames) {
+      return type;
+    }
+    const typeDisplay = {
+      function: "->",
+      add: "++",
+      addMany: "+!",
+      modify: "+-",
+      append: "_+",
+      skip: "--"
+    };
+    return typeDisplay[type] ?? type;
+  }
+  formatActionTargetForDisplay(value) {
+    if (process.platform !== "win32") {
+      return value;
+    }
+    const normalized = value.replaceAll("/", "\\");
+    if (!normalized.startsWith("\\") && !/^[A-Za-z]:\\/.test(normalized)) {
+      return `\\${normalized}`;
+    }
+    return normalized;
+  }
+  // ── Private ───────────────────────────────────────────────────────
+  registerBuiltInHelpers() {
+    const applyCase = (formatter) => {
+      return (value) => formatter(String(value ?? ""));
+    };
+    const helperMap = {
+      camelCase: applyCase(camelCase),
+      snakeCase: applyCase(snakeCase),
+      dashCase: applyCase(kebabCase),
+      kabobCase: applyCase(kebabCase),
+      kebabCase: applyCase(kebabCase),
+      dotCase: applyCase(dotCase),
+      pathCase: applyCase(pathCase),
+      properCase: applyCase(pascalCase),
+      pascalCase: applyCase(pascalCase),
+      lowerCase: (value) => String(value ?? "").toLowerCase(),
+      upperCase: (value) => String(value ?? "").toUpperCase(),
+      sentenceCase: applyCase(sentenceCase),
+      constantCase: applyCase(constantCase),
+      titleCase: applyCase(titleCase),
+      pkg: (propertyPath) => this.readPackageProperty(propertyPath)
+    };
+    for (const [name, helper] of Object.entries(helperMap)) {
+      this.registerHelper(name, helper);
+    }
+  }
+  readPackageProperty(propertyPath) {
+    if (typeof propertyPath !== "string" || propertyPath.trim().length === 0) {
+      return "";
+    }
+    const pkg = this.loadPackageJsonNearPlopfile();
+    if (!pkg) {
+      return "";
+    }
+    const value = this.getPathValue(pkg, propertyPath);
+    if (value === void 0 || value === null) {
+      return "";
+    }
+    return String(value);
+  }
+  loadPackageJsonNearPlopfile() {
+    const baseDirectory = this.plopfilePath ? dirname2(this.plopfilePath) : this.destBasePath;
+    const packagePath = resolve2(baseDirectory, "package.json");
+    if (this.pkgCachePath === packagePath) {
+      return this.pkgCache;
+    }
+    this.pkgCachePath = packagePath;
+    if (!existsSync2(packagePath)) {
+      this.pkgCache = void 0;
+      return void 0;
+    }
+    try {
+      const raw = readFileSync(packagePath, "utf8");
+      const parsed = JSON.parse(raw);
+      this.pkgCache = parsed;
+      return parsed;
+    } catch {
+      this.pkgCache = void 0;
+      return void 0;
+    }
+  }
+  getPathValue(source, propertyPath) {
+    const segments = propertyPath.split(".").filter((segment) => segment.length > 0);
+    let current = source;
+    for (const segment of segments) {
+      if (current === null || typeof current !== "object") {
+        return void 0;
+      }
+      const record = current;
+      if (!(segment in record)) {
+        return void 0;
+      }
+      current = record[segment];
+    }
+    return current;
+  }
+  /**
+   * Returns prepared prompts for a generator: prompt `message` fields are
+   * transformed by plugins (like i18n) before they are rendered by Inquirer.
+   */
+  preparePrompts(generatorName, prompts) {
+    return this.i18nAdapter?.preparePrompts(generatorName, prompts) ?? prompts;
+  }
+  resolvePromptTheme(type) {
+    const theme = this.resolvePromptTypeTheme(type);
+    return this.promptThemeSelectorRegistry.resolveTheme(type, theme);
+  }
+  /**
+   * Resolve the full theme for a specific prompt type.
+   * Merges in order: defaultTheme → type defaults → user global theme → user type theme.
+   */
+  resolvePromptTypeTheme(type) {
+    if (type === "generator-select") {
+      const selectDefaults = PROMPT_TYPE_THEMES["select"];
+      const userSelectTheme = this.resolveUserPromptTypeTheme("select");
+      const userGeneratorSelectTheme = this.resolveUserPromptTypeTheme(type);
+      return this.mergeThemeLayers(
+        selectDefaults,
+        this.resolveNormalizedGlobalTheme(),
+        userSelectTheme,
+        userGeneratorSelectTheme
+      );
+    }
+    const typeDefaults = PROMPT_TYPE_THEMES[type];
+    const userTypeTheme = this.resolveUserPromptTypeTheme(type);
+    return this.mergeThemeLayers(
+      typeDefaults,
+      this.resolveNormalizedGlobalTheme(),
+      userTypeTheme
+    );
+  }
+  resolveTheme() {
+    return this.mergeThemeLayers(this.resolveNormalizedGlobalTheme());
+  }
+  cloneTheme(theme) {
+    return this.cloneUnknown(theme);
+  }
+  resolveNormalizedGlobalTheme() {
+    return this.normalizeThemeScope(this.theme);
+  }
+  resolveUserPromptTypeTheme(type) {
+    const source = this.theme;
+    const rawTypeTheme = source[type];
+    if (!this.isRecord(rawTypeTheme)) {
+      return void 0;
+    }
+    return this.normalizeThemeScope(rawTypeTheme);
+  }
+  normalizeThemeScope(source) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(source)) {
+      if (this.isPromptThemeTypeKey(key)) continue;
+      if (key === "waitingMessage" || key === "maskedText" || key === "disabledError") {
+        continue;
+      }
+      normalized[key] = value;
+    }
+    const style = this.isRecord(normalized.style) ? { ...normalized.style } : {};
+    if (source.waitingMessage !== void 0) {
+      if (typeof source.waitingMessage === "function") {
+        style.waitingMessage = source.waitingMessage;
+      } else if (typeof source.waitingMessage === "string") {
+        const template = source.waitingMessage;
+        style.waitingMessage = (enterKey) => template.replaceAll("{{enterKey}}", enterKey).replaceAll("{enterKey}", enterKey);
+      }
+    }
+    if (typeof source.maskedText === "string") {
+      style.maskedText = source.maskedText;
+    }
+    if (Object.keys(style).length > 0) {
+      normalized.style = style;
+    }
+    const i18n = this.isRecord(normalized.i18n) ? { ...normalized.i18n } : {};
+    if (typeof source.disabledError === "string") {
+      i18n.disabledError = source.disabledError;
+    }
+    if (Object.keys(i18n).length > 0) {
+      normalized.i18n = i18n;
+    }
+    return normalized;
+  }
+  mergeThemeLayers(...layers) {
+    const mergedTheme = {
+      icon: defaultTheme.icon,
+      prefix: defaultTheme.prefix,
+      spinner: {
+        ...defaultTheme.spinner,
+        frames: [...defaultTheme.spinner?.frames ?? []]
+      },
+      style: {
+        ...defaultTheme.style
+      },
+      validationFailureMode: defaultTheme.validationFailureMode,
+      indexMode: defaultTheme.indexMode,
+      i18n: {
+        ...defaultTheme.i18n
+      },
+      keybindings: defaultTheme.keybindings,
+      plopNext: {
+        ...defaultTheme.plopNext,
+        generatorMenu: {
+          ...defaultTheme.plopNext?.generatorMenu
+        },
+        actionLog: {
+          ...defaultTheme.plopNext?.actionLog
+        },
+        errors: {
+          ...defaultTheme.plopNext?.errors,
+          prefix: {
+            ...defaultTheme.plopNext?.errors?.prefix
+          }
+        }
+      }
+    };
+    for (const layer of layers) {
+      if (!layer) continue;
+      mergedTheme.icon = this.mergeIconLayers(mergedTheme.icon, layer.icon);
+      if (layer.prefix !== void 0) {
+        mergedTheme.prefix = layer.prefix;
+      }
+      if (layer.spinner) {
+        mergedTheme.spinner = {
+          ...mergedTheme.spinner,
+          ...layer.spinner,
+          ...Array.isArray(layer.spinner.frames) ? { frames: [...layer.spinner.frames] } : {}
+        };
+      }
+      if (layer.style) {
+        mergedTheme.style = {
+          ...mergedTheme.style,
+          ...layer.style
+        };
+      }
+      if (layer.validationFailureMode !== void 0) {
+        mergedTheme.validationFailureMode = layer.validationFailureMode;
+      }
+      if (layer.indexMode !== void 0) {
+        mergedTheme.indexMode = layer.indexMode;
+      }
+      if (layer.i18n) {
+        mergedTheme.i18n = {
+          ...mergedTheme.i18n,
+          ...layer.i18n
+        };
+      }
+      if (layer.keybindings !== void 0) {
+        mergedTheme.keybindings = [...layer.keybindings];
+      }
+      if (layer.plopNext) {
+        mergedTheme.plopNext = {
+          ...mergedTheme.plopNext,
+          ...layer.plopNext,
+          generatorMenu: {
+            ...mergedTheme.plopNext?.generatorMenu,
+            ...layer.plopNext.generatorMenu
+          },
+          actionLog: {
+            ...mergedTheme.plopNext?.actionLog,
+            ...layer.plopNext.actionLog
+          },
+          errors: {
+            ...mergedTheme.plopNext?.errors,
+            ...layer.plopNext.errors,
+            prefix: {
+              ...mergedTheme.plopNext?.errors?.prefix,
+              ...layer.plopNext.errors?.prefix
+            }
+          }
+        };
+      }
+    }
+    return mergedTheme;
+  }
+  looksLikeThemeSource(value) {
+    const keys = Object.keys(value);
+    if (keys.length === 0) {
+      return false;
+    }
+    const rootThemeKeys = /* @__PURE__ */ new Set([
+      "icon",
+      "prefix",
+      "spinner",
+      "style",
+      "validationFailureMode",
+      "indexMode",
+      "i18n",
+      "keybindings",
+      "plopNext",
+      "waitingMessage",
+      "maskedText",
+      "disabledError"
+    ]);
+    return keys.some(
+      (key) => rootThemeKeys.has(key) || this.isPromptThemeTypeKey(key)
+    );
+  }
+  looksLikeI18nSource(value) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return false;
+    }
+    const localeBundle = entries.every(
+      ([key, item]) => this.isLocaleLikeKey(key) && this.isRecord(item)
+    );
+    if (localeBundle) {
+      return true;
+    }
+    const knownI18nRoots = /* @__PURE__ */ new Set([
+      "cli",
+      "inquirer",
+      "actions",
+      "errors",
+      "help"
+    ]);
+    return entries.some(([key]) => knownI18nRoots.has(key));
+  }
+  isLocaleLikeKey(key) {
+    return /^[a-z]{2}(?:[-_][A-Za-z0-9]{2,8})*$/i.test(key);
+  }
+  isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  isPromptThemeTypeKey(key) {
+    return BUILT_IN_PROMPT_TYPES.includes(key);
+  }
+  unwrapModuleDefault(value) {
+    if (!this.isRecord(value)) {
+      return value;
+    }
+    const defaultValue = value["default"];
+    if (typeof defaultValue !== "undefined") {
+      return defaultValue;
+    }
+    return value;
+  }
+  cloneUnknown(value) {
+    if (Array.isArray(value)) {
+      return value.map((item) => this.cloneUnknown(item));
+    }
+    if (this.isRecord(value)) {
+      const cloned = {};
+      for (const [key, item] of Object.entries(value)) {
+        cloned[key] = this.cloneUnknown(item);
+      }
+      return cloned;
+    }
+    return value;
+  }
+  /**
+   * Merge icon values when applying one layer over another.
+   */
+  mergeIconLayers(base, override) {
+    if (override === void 0) return base;
+    if (typeof override === "string") return override;
+    if (typeof base === "string" || base === void 0) {
+      return { ...override };
+    }
+    return { ...base, ...override };
+  }
+};
+
+// src/defaultTexts.ts
+var CORE_DEFAULT_TEXTS = {
+  cli: {
+    title: "Welcome to plop-next! \u{1F680}",
+    welcomeMessage: null,
+    selectGenerator: "Please choose a generator",
+    noGenerators: "No generators registered. Add some to your plopfile.",
+    generatorNotFound: (name) => `Generator "${name}" not found.`,
+    aborted: "Aborted.",
+    done: "Done!",
+    promptCancelled: "Console exited by user."
+  },
+  inquirer: {
+    confirm: {
+      yesLabel: "Yes",
+      noLabel: "No",
+      hintYes: "Y/n",
+      hintNo: "y/N"
+    },
+    select: {
+      helpNavigate: "navigate",
+      helpSelect: "select"
+    },
+    checkbox: {
+      helpNavigate: "navigate",
+      helpSelect: "select",
+      helpSubmit: "submit",
+      helpAll: "toggle all",
+      helpInvert: "invert selection"
+    },
+    search: {
+      helpNavigate: "navigate",
+      helpSelect: "select"
+    },
+    editor: {
+      waitingMessage: (enterKey) => `Press ${enterKey} to launch your preferred editor.`
+    },
+    password: {
+      maskedText: "[input is hidden]"
+    }
+  },
+  actions: {
+    add: {
+      creating: (path) => `Creating ${path}`,
+      created: (path) => `\u2714 Created ${path}`,
+      alreadyExists: (path) => `File already exists: ${path}`
+    },
+    modify: {
+      modifying: (path) => `Modifying ${path}`,
+      modified: (path) => `\u2714 Modified ${path}`,
+      notFound: (path) => `File not found: ${path}`,
+      patternNotFound: (path) => `Pattern not found in: ${path}`
+    },
+    append: {
+      appending: (path) => `Appending to ${path}`,
+      appended: (path) => `\u2714 Appended to ${path}`
+    }
+  },
+  errors: {
+    unknownAction: (type) => `Unknown action type: "${type}"`,
+    plopfileNotFound: "Could not find a plopfile (plopfile.js or plopfile.ts).",
+    plopfileLoadFailed: (err) => `Failed to load plopfile: ${err}`,
+    generatorNotFound: (name) => `Generator "${name}" not found.`,
+    noGenerators: "No generators registered. Add some to your plopfile.",
+    invalidPrompt: (name, reason) => `Invalid prompt "${name}": ${reason}`,
+    bypassParse: (promptName, promptType, value, detail) => `Cannot assign bypass value "${value}" to ${promptType} prompt "${promptName}"${detail ? `: ${detail}` : ""}`,
+    plopfileLoad: (path) => `Failed to load plopfile: ${path}`,
+    plopfileExport: "Plopfile must export a default function.",
+    userCancelled: "Prompt cancelled by user.",
+    plopfileNotFoundWarning: "No plopfile found. Create a plopfile.js in your project.",
+    forcedLangI18nMissing: (locale) => `Forced locale "${locale}" ignored because @plop-next/i18n is not installed. Falling back to English.`,
+    forcedLangUnavailable: (locale) => `Forced locale "${locale}" is not available. Falling back to English.`
+  },
+  /**
+   * CLI `--help` display texts.
+   * These are read-only and cannot be overridden via `registerLocale` / `registerTexts`.
+   */
+  help: {
+    usage: "Usage:",
+    usage1: "Select from a list of available generators",
+    usage2: "Run a generator registered under that name",
+    usage3: "Run the generator with input data to bypass prompts",
+    options: "Options:",
+    optHelp: "Show this help display",
+    optShowTypeNames: "Show type names instead of abbreviations",
+    optInitTitle: "Plopfile initialization",
+    optGenerateTitle: "Generate Locale, Texts, Theme files",
+    optOthersTitle: "Other options",
+    optInit: "Generate a basic plopfile.ts",
+    optInitJs: "Generate a basic plopfile.js",
+    optInitTs: "Generate a basic plopfile.ts",
+    optDemo: "Generate a demo generator in the plopfile",
+    optI18n: "Initialize plopfile with i18n support",
+    optGenerate: "Generate template: locale | texts | theme",
+    optPath: "Base output directory for generated template files",
+    optExtension: "Generated file extension: ts | js | json",
+    optIncludeCustomTexts: "For locale generation, include translatable keys from plopfile",
+    optVersion: "Print current version",
+    optForce: "Run the generator forcefully",
+    optLang: "Force display locale (e.g. en, fr)",
+    danger: "danger waits for those who venture below the line",
+    lowPlopfile: "Path to the plopfile",
+    lowCwd: "Directory from which relative paths are calculated while locating the plopfile",
+    lowPreload: "String or array of modules to require before running plop-next",
+    lowDest: "Output to this directory instead of the plopfile parent directory",
+    lowNoProgress: "Disable the progress spinner",
+    examples: "Examples:"
+  }
+};
+var CORE_DEFAULT_TEXTS_EN = CORE_DEFAULT_TEXTS;
+var CORE_DEFAULT_HELP_TEXTS = CORE_DEFAULT_TEXTS.help;
+
+// src/prompts/Separator.ts
+var Separator = class {
+  constructor(separator) {
+    this.type = "separator";
+    this.separator = separator ?? "---------------";
+  }
+  static isSeparator(choice) {
+    return Boolean(
+      choice && typeof choice === "object" && "type" in choice && choice.type === "separator"
+    );
+  }
+};
+
+// src/errors/ErrorHandler.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { appendFileSync } from "fs";
+import { dirname as dirname3 } from "path";
+var ErrorHandler = class {
+  constructor(options) {
+    this.verbosity = "simple";
+    this.useColors = true;
+    this.errorPrefix = defaultTheme.plopNext?.errors?.prefix?.error ?? "\u2716";
+    this.warningPrefix = defaultTheme.plopNext?.errors?.prefix?.warning ?? "\u26A0";
+    this.errorStyle = defaultTheme.plopNext?.errors?.error ?? ((text) => import_picocolors.default.red(text));
+    this.warningStyle = defaultTheme.plopNext?.errors?.warning ?? ((text) => import_picocolors.default.yellow(text));
+    if (options?.verbosity) this.verbosity = options.verbosity;
+    if (options?.logFile) this.logFile = options.logFile;
+    if (options?.useColors !== void 0) this.useColors = options.useColors;
+    if (options?.theme) {
+      this.applyTheme(options.theme);
+    }
+  }
+  /**
+   * Handle and output an error.
+   * Returns exit behavior and code.
+   */
+  handle(error) {
+    const isPlopError = this.isPlopError(error);
+    if (isPlopError) {
+      const output2 = this.formatError(error);
+      this.logToConsole(output2, true, error.config.isWarning);
+      this.logToFile(output2, error.config.allowLogFile);
+      return {
+        exitCode: error.config.exitCode,
+        shouldExit: error.config.shouldExit
+      };
+    }
+    const output = this.formatError(error);
+    this.logToConsole(output, false, false);
+    this.logToFile(output, true);
+    return {
+      exitCode: 1,
+      shouldExit: true
+    };
+  }
+  isPlopError(error) {
+    return error instanceof Error && "code" in error;
+  }
+  formatError(error) {
+    if (!this.isPlopError(error)) {
+      return this.formatUnhandledError(error);
+    }
+    switch (this.verbosity) {
+      case "simple":
+        return this.formatSimple(error);
+      case "verbose":
+        return this.formatVerbose(error);
+      case "debug":
+        return this.formatDebug(error);
+    }
+  }
+  formatSimple(error) {
+    return this.resolveMessage(error);
+  }
+  formatVerbose(error) {
+    const parts = [];
+    parts.push(`[${error.code}] ${this.resolveMessage(error)}`);
+    if (error.config.showStackTrace && error instanceof Error && error.stack) {
+      const stackLines = error.stack.split("\n").slice(1, 4);
+      if (stackLines.length > 0) {
+        parts.push("\nStack:");
+        parts.push(stackLines.join("\n"));
+      }
+    }
+    return parts.join("\n");
+  }
+  formatDebug(error) {
+    const parts = [];
+    parts.push(`Error Code: ${error.code}`);
+    parts.push(`Message: ${this.resolveMessage(error)}`);
+    parts.push(`Type: ${error.name}`);
+    parts.push(`Operational: ${error.isOperational}`);
+    if (error.config.showStackTrace && error.stack) {
+      parts.push("\nFull Stack Trace:");
+      parts.push(error.stack);
+    }
+    const customKeys = Object.keys(error).filter(
+      (k) => !["message", "name", "code", "isOperational", "stack", "config"].includes(k)
+    );
+    if (customKeys.length > 0) {
+      parts.push("\nAdditional Context:");
+      for (const key of customKeys) {
+        const value = error[key];
+        if (value instanceof Error) {
+          parts.push(`  ${key}:`);
+          parts.push(`    ${value.message}`);
+        } else {
+          parts.push(`  ${key}: ${JSON.stringify(value)}`);
+        }
+      }
+    }
+    return parts.join("\n");
+  }
+  formatUnhandledError(error) {
+    let message = "An unexpected error occurred.";
+    if (error instanceof Error) {
+      message = error.message;
+      if (this.verbosity === "debug" && error.stack) {
+        message += `
+${error.stack}`;
+      }
+    } else if (typeof error === "string") {
+      message = error;
+    } else {
+      message = String(error);
+    }
+    return message;
+  }
+  resolveMessage(error) {
+    if (!error.translation) {
+      return error.message;
+    }
+    return this.translator?.(
+      error.translation.key,
+      error.translation.args,
+      error.translation.fallback
+    ) ?? error.translation.fallback;
+  }
+  logToConsole(output, isPlopError, isWarning) {
+    const prefix = isWarning ? this.warningPrefix : this.errorPrefix;
+    const text = `${prefix} ${output}`;
+    if (this.useColors && isPlopError) {
+      if (isWarning) {
+        console.error(this.warningStyle(text));
+        return;
+      }
+      console.error(this.errorStyle(text));
+    } else {
+      console.error(text);
+    }
+  }
+  logToFile(output, allowLogFile = true) {
+    if (!this.logFile || !allowLogFile) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logEntry = `[${timestamp}] ${output}
+`;
+    try {
+      const dir = dirname3(this.logFile);
+      if (dir !== ".") {
+      }
+      appendFileSync(this.logFile, logEntry);
+    } catch (e) {
+    }
+  }
+  setVerbosity(verbosity) {
+    this.verbosity = verbosity;
+  }
+  setLogFile(logFile) {
+    this.logFile = logFile;
+  }
+  setTheme(theme) {
+    if (!theme?.plopNext?.errors) {
+      return;
+    }
+    this.applyTheme(theme.plopNext.errors);
+  }
+  setTranslator(translator) {
+    this.translator = translator;
+  }
+  applyTheme(theme) {
+    if (theme.prefix?.error) this.errorPrefix = theme.prefix.error;
+    if (theme.prefix?.warning) this.warningPrefix = theme.prefix.warning;
+    if (theme.error) this.errorStyle = theme.error;
+    if (theme.warning) this.warningStyle = theme.warning;
+  }
+};
+
+// src/errors/PlopError.ts
+function resolveDefaultErrorText(key, args = []) {
+  const value = CORE_DEFAULT_TEXTS.errors[key];
+  if (typeof value === "function") {
+    return String(value(...args));
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return key;
+}
+var PlopError = class _PlopError extends Error {
+  constructor(code, message, config, translation) {
+    super(message);
+    this.isOperational = true;
+    this.code = code;
+    this.config = config;
+    this.translation = translation;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, _PlopError.prototype);
+  }
+};
+var GeneratorNotFoundError = class _GeneratorNotFoundError extends PlopError {
+  constructor(generatorName) {
+    const args = [generatorName];
+    const fallback = resolveDefaultErrorText("generatorNotFound", args);
+    super(
+      "GENERATOR_NOT_FOUND",
+      fallback,
+      {
+        isWarning: false,
+        shouldExit: true,
+        exitCode: 1,
+        showStackTrace: false,
+        allowLogFile: true
+      },
+      { key: "errors.generatorNotFound", args, fallback }
+    );
+    Object.setPrototypeOf(this, _GeneratorNotFoundError.prototype);
+  }
+};
+var NoGeneratorsError = class _NoGeneratorsError extends PlopError {
+  constructor() {
+    const fallback = resolveDefaultErrorText("noGenerators");
+    super(
+      "NO_GENERATORS",
+      fallback,
+      {
+        isWarning: false,
+        shouldExit: true,
+        exitCode: 1,
+        showStackTrace: false,
+        allowLogFile: true
+      },
+      { key: "errors.noGenerators", fallback }
+    );
+    Object.setPrototypeOf(this, _NoGeneratorsError.prototype);
+  }
+};
+var InvalidPromptError = class _InvalidPromptError extends PlopError {
+  constructor(promptName, reason) {
+    const args = [promptName, reason];
+    const fallback = resolveDefaultErrorText("invalidPrompt", args);
+    super(
+      "INVALID_PROMPT",
+      fallback,
+      {
+        isWarning: false,
+        shouldExit: true,
+        exitCode: 1,
+        showStackTrace: false,
+        allowLogFile: true
+      },
+      { key: "errors.invalidPrompt", args, fallback }
+    );
+    Object.setPrototypeOf(this, _InvalidPromptError.prototype);
+  }
+};
+var BypassParseError = class _BypassParseError extends PlopError {
+  constructor(promptName, promptType, value, reason) {
+    const args = [promptName, promptType, value, reason];
+    const fallback = resolveDefaultErrorText("bypassParse", args);
+    super(
+      "BYPASS_PARSE_ERROR",
+      fallback,
+      {
+        isWarning: false,
+        shouldExit: true,
+        exitCode: 1,
+        showStackTrace: false,
+        allowLogFile: true
+      },
+      { key: "errors.bypassParse", args, fallback }
+    );
+    Object.setPrototypeOf(this, _BypassParseError.prototype);
+  }
+};
+var PlopfileLoadError = class _PlopfileLoadError extends PlopError {
+  constructor(filePath, requireError, importError) {
+    const args = [filePath];
+    const fallback = resolveDefaultErrorText("plopfileLoad", args);
+    super(
+      "PLOPFILE_LOAD_ERROR",
+      fallback,
+      {
+        isWarning: false,
+        shouldExit: true,
+        exitCode: 1,
+        showStackTrace: true,
+        allowLogFile: true
+      },
+      { key: "errors.plopfileLoad", args, fallback }
+    );
+    this.requireError = requireError;
+    this.importError = importError;
+    Object.setPrototypeOf(this, _PlopfileLoadError.prototype);
+  }
+};
+var PlopfileExportError = class _PlopfileExportError extends PlopError {
+  constructor(message) {
+    const fallback = message ?? resolveDefaultErrorText("plopfileExport");
+    super(
+      "PLOPFILE_EXPORT_ERROR",
+      fallback,
+      {
+        isWarning: false,
+        shouldExit: true,
+        exitCode: 1,
+        showStackTrace: false,
+        allowLogFile: true
+      },
+      message ? void 0 : { key: "errors.plopfileExport", fallback }
+    );
+    Object.setPrototypeOf(this, _PlopfileExportError.prototype);
+  }
+};
+var UserCancelledError = class _UserCancelledError extends PlopError {
+  constructor() {
+    const fallback = resolveDefaultErrorText("userCancelled");
+    super(
+      "USER_CANCELLED",
+      fallback,
+      {
+        isWarning: true,
+        shouldExit: true,
+        exitCode: 0,
+        showStackTrace: false,
+        allowLogFile: false
+      },
+      { key: "errors.userCancelled", fallback }
+    );
+    Object.setPrototypeOf(this, _UserCancelledError.prototype);
+  }
+};
+var PlopfileNotFoundWarning = class _PlopfileNotFoundWarning extends PlopError {
+  constructor(message) {
+    const fallback = message ?? resolveDefaultErrorText("plopfileNotFoundWarning");
+    super(
+      "PLOPFILE_NOT_FOUND",
+      fallback,
+      {
+        isWarning: true,
+        shouldExit: true,
+        exitCode: 1,
+        showStackTrace: false,
+        allowLogFile: false
+      },
+      message ? void 0 : { key: "errors.plopfileNotFoundWarning", fallback }
+    );
+    Object.setPrototypeOf(this, _PlopfileNotFoundWarning.prototype);
+  }
+};
+var ForcedLangFallbackWarning = class _ForcedLangFallbackWarning extends PlopError {
+  constructor(locale, reason) {
+    const args = [locale];
+    const key = reason === "i18n-missing" ? "forcedLangI18nMissing" : "forcedLangUnavailable";
+    const fallback = resolveDefaultErrorText(key, args);
+    super(
+      "FORCED_LANG_FALLBACK",
+      fallback,
+      {
+        isWarning: true,
+        shouldExit: false,
+        exitCode: 0,
+        showStackTrace: false,
+        allowLogFile: false
+      },
+      {
+        key: `errors.${key}`,
+        args,
+        fallback
+      }
+    );
+    this.locale = locale;
+    this.reason = reason;
+    Object.setPrototypeOf(this, _ForcedLangFallbackWarning.prototype);
+  }
+};
+var I18nSourceWarning = class _I18nSourceWarning extends PlopError {
+  constructor(message) {
+    super(
+      "I18N_SOURCE_WARNING",
+      message,
+      {
+        isWarning: true,
+        shouldExit: false,
+        exitCode: 0,
+        showStackTrace: false,
+        allowLogFile: false
+      }
+    );
+    Object.setPrototypeOf(this, _I18nSourceWarning.prototype);
+  }
+};
+export {
+  ActionRunner,
+  BypassParseError,
+  CORE_DEFAULT_HELP_TEXTS,
+  CORE_DEFAULT_TEXTS,
+  CORE_DEFAULT_TEXTS_EN,
+  ErrorHandler,
+  ForcedLangFallbackWarning,
+  GeneratorNotFoundError,
+  I18nSourceWarning,
+  InvalidPromptError,
+  NoGeneratorsError,
+  PROMPT_TYPE_THEMES,
+  PlopError,
+  PlopNextCore,
+  PlopfileExportError,
+  PlopfileLoadError,
+  PlopfileNotFoundWarning,
+  PromptHandlerRegistry,
+  Separator,
+  UserCancelledError,
+  askCustomPrompt,
+  createCheckboxHandler,
+  createConfirmHandler,
+  createEditorHandler,
+  createPasswordHandler,
+  createPromptThemeSelector,
+  createSearchHandler,
+  createSelectHandler,
+  defaultTheme,
+  getCustomPrompt,
+  listCustomPromptTypes,
+  registerBuiltInPromptHandlers,
+  registerCustomPrompt
+};