simple-scaffold 2.3.2 → 3.0.0

package/scaffold-Ce-rIwy9.js

@@ -0,0 +1,2636 @@
+//#region \0rolldown/runtime.js
+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 __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_os = require("node:os");
+node_os = __toESM(node_os);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let glob = require("glob");
+let handlebars = require("handlebars");
+handlebars = __toESM(handlebars);
+let date_fns = require("date-fns");
+let node_constants = require("node:constants");
+let node_child_process = require("node:child_process");
+let node_util = require("node:util");
+//#region src/colors.ts
+/** ANSI color code mapping for terminal output. */
+var colorMap = {
+	reset: 0,
+	dim: 2,
+	bold: 1,
+	italic: 3,
+	underline: 4,
+	red: 31,
+	green: 32,
+	yellow: 33,
+	blue: 34,
+	magenta: 35,
+	cyan: 36,
+	white: 37,
+	gray: 90
+};
+function _colorize(text, color) {
+	const c = colorMap[color];
+	let r = 0;
+	if (c > 1 && c < 30) r = c + 20;
+	else if (c === 1) r = 23;
+	else r = 0;
+	return `\x1b[${c}m${text}\x1b[${r}m`;
+}
+function isTemplateStringArray(template) {
+	return Array.isArray(template) && typeof template[0] === "string";
+}
+var createColorize = (color) => (template, ...params) => {
+	return isTemplateStringArray(template) ? _colorize(template.reduce((acc, str, i) => acc + str + (params[i] ?? ""), ""), color) : _colorize(String(template), color);
+};
+/**
+* Colorize text for terminal output.
+*
+* Can be used as a function: `colorize("text", "red")`
+* Or via named helpers: `colorize.red("text")` / `colorize.red\`template\``
+*/
+var colorize = Object.assign(_colorize, Object.entries(colorMap).reduce((acc, [key]) => {
+	acc[key] = createColorize(key);
+	return acc;
+}, {}));
+//#endregion
+//#region src/utils.ts
+/** Throws the error if non-null, no-ops otherwise. */
+function handleErr(err) {
+	if (err) throw err;
+}
+/** Resolves a value that may be either a static value or a function that produces one. */
+function resolve(resolver, arg) {
+	return typeof resolver === "function" ? resolver(arg) : resolver;
+}
+/** Wraps a static value in a resolver function. If already a function, returns as-is. */
+function wrapNoopResolver(value) {
+	if (typeof value === "function") return value;
+	return (_) => value;
+}
+//#endregion
+//#region src/types.ts
+/**
+* The amount of information to log when generating scaffold.
+* When not `none`, the selected level will be the lowest level included.
+*
+* For example, level `info`  will include `info`, `warning` and `error`, but not `debug`; and `warning` will only
+* show `warning` and `error`, but not `info` or `debug`.
+*
+* @default `info`
+*
+* @category Logging (const)
+*/
+var LogLevel = {
+	none: "none",
+	debug: "debug",
+	info: "info",
+	warning: "warning",
+	error: "error"
+};
+//#endregion
+//#region __vite-browser-external
+var require___vite_browser_external = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {};
+}));
+//#endregion
+//#region src/logger.ts
+var import___vite_browser_external = /* @__PURE__ */ __toESM(require___vite_browser_external());
+/** Priority ordering for log levels (higher = more severe). */
+var LOG_PRIORITY = {
+	[LogLevel.none]: 0,
+	[LogLevel.debug]: 1,
+	[LogLevel.info]: 2,
+	[LogLevel.warning]: 3,
+	[LogLevel.error]: 4
+};
+/** Maps each log level to a terminal color. */
+var LOG_LEVEL_COLOR = {
+	[LogLevel.none]: "reset",
+	[LogLevel.debug]: "blue",
+	[LogLevel.info]: "dim",
+	[LogLevel.warning]: "yellow",
+	[LogLevel.error]: "red"
+};
+/** Logs a message at the given level, respecting the configured log level filter. */
+function log(config, level, ...obj) {
+	if (config.logLevel === LogLevel.none || LOG_PRIORITY[level] < LOG_PRIORITY[config.logLevel ?? LogLevel.info]) return;
+	const colorFn = colorize[LOG_LEVEL_COLOR[level]];
+	const key = level === LogLevel.error ? "error" : level === LogLevel.warning ? "warn" : "log";
+	const logFn = console[key];
+	logFn(...obj.map((i) => i instanceof Error ? colorFn(i, JSON.stringify(i, void 0, 1), i.stack) : typeof i === "object" ? import___vite_browser_external.default.inspect(i, {
+		depth: null,
+		colors: true
+	}) : colorFn(i)));
+}
+/** Logs the full scaffold configuration at debug level, with a data summary at info level. */
+function logInitStep(config) {
+	log(config, LogLevel.debug, "Full config:", {
+		name: config.name,
+		templates: config.templates,
+		output: config.output,
+		subdir: config.subdir,
+		data: config.data,
+		overwrite: config.overwrite,
+		subdirHelper: config.subdirHelper,
+		helpers: Object.keys(config.helpers ?? {}),
+		logLevel: config.logLevel,
+		dryRun: config.dryRun,
+		beforeWrite: config.beforeWrite
+	});
+	log(config, LogLevel.info, "Data:", config.data);
+}
+//#endregion
+//#region src/parser.ts
+var dateFns = {
+	add: date_fns.add,
+	format: date_fns.format,
+	parseISO: date_fns.parseISO
+};
+var defaultHelpers = {
+	camelCase,
+	snakeCase,
+	startCase,
+	kebabCase,
+	hyphenCase: kebabCase,
+	pascalCase,
+	lowerCase: (text) => text.toLowerCase(),
+	upperCase: (text) => text.toUpperCase(),
+	now: nowHelper,
+	date: dateHelper
+};
+function _dateHelper(date, formatString, durationDifference, durationType) {
+	if (durationType && durationDifference !== void 0) return dateFns.format(dateFns.add(date, { [durationType]: durationDifference }), formatString);
+	return dateFns.format(date, formatString);
+}
+function nowHelper(formatString, durationDifference, durationType) {
+	return _dateHelper(/* @__PURE__ */ new Date(), formatString, durationDifference, durationType);
+}
+function dateHelper(date, formatString, durationDifference, durationType) {
+	return _dateHelper(dateFns.parseISO(date), formatString, durationDifference, durationType);
+}
+function toWordParts(string) {
+	return string.split(/[^a-zA-Z0-9]/).flatMap((segment) => segment.split(/(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/)).filter((s) => s.length > 0);
+}
+function camelCase(s) {
+	return toWordParts(s).reduce((acc, part, i) => {
+		if (i === 0) return part.toLowerCase();
+		return acc + part[0].toUpperCase() + part.slice(1).toLowerCase();
+	}, "");
+}
+function snakeCase(s) {
+	return toWordParts(s).join("_").toLowerCase();
+}
+function kebabCase(s) {
+	return toWordParts(s).join("-").toLowerCase();
+}
+function startCase(s) {
+	return toWordParts(s).map((part) => part[0].toUpperCase() + part.slice(1).toLowerCase()).join(" ");
+}
+function pascalCase(s) {
+	return startCase(s).replace(/\s+/g, "");
+}
+function registerHelpers(config) {
+	const _helpers = {
+		...defaultHelpers,
+		...config.helpers
+	};
+	for (const helperName in _helpers) {
+		log(config, LogLevel.debug, `Registering helper: ${helperName}`);
+		handlebars.default.registerHelper(helperName, _helpers[helperName]);
+	}
+}
+function handlebarsParse(config, templateBuffer, { asPath = false } = {}) {
+	const { data } = config;
+	try {
+		let str = templateBuffer.toString();
+		if (asPath) str = str.replace(/\\/g, "/");
+		let outputContents = handlebars.default.compile(str, { noEscape: true })(data);
+		if (asPath && node_path.default.sep !== "/") outputContents = outputContents.replace(/\//g, "\\");
+		return Buffer.from(outputContents);
+	} catch (e) {
+		log(config, LogLevel.debug, e);
+		log(config, LogLevel.info, "Couldn't parse file with handlebars, returning original content");
+		return Buffer.from(templateBuffer);
+	}
+}
+//#endregion
+//#region src/fs-utils.ts
+var { stat, access, mkdir } = node_fs_promises.default;
+/** Recursively creates a directory and its parents if they don't exist. */
+async function createDirIfNotExists(dir, config) {
+	if (config.dryRun) {
+		log(config, LogLevel.info, `Dry Run. Not creating dir ${dir}`);
+		return;
+	}
+	const parentDir = node_path.default.dirname(dir);
+	if (!await pathExists(parentDir)) await createDirIfNotExists(parentDir, config);
+	if (!await pathExists(dir)) try {
+		log(config, LogLevel.debug, `Creating dir ${dir}`);
+		await mkdir(dir);
+		return;
+	} catch (e) {
+		if (e && e.code !== "EEXIST") throw e;
+		return;
+	}
+}
+/** Checks whether a file or directory exists at the given path. */
+async function pathExists(filePath) {
+	try {
+		await access(filePath, node_constants.F_OK);
+		return true;
+	} catch (e) {
+		if (e && e.code === "ENOENT") return false;
+		throw e;
+	}
+}
+/** Returns true if the given path is a directory. */
+async function isDir(dirPath) {
+	return (await stat(dirPath)).isDirectory();
+}
+/** Generates a unique temporary directory path for scaffold operations. @internal */
+function getUniqueTmpPath() {
+	return node_path.default.resolve(node_os.default.tmpdir(), `scaffold-config-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+}
+//#endregion
+//#region src/path-utils.ts
+/** Strips glob wildcard characters from a template path. */
+function removeGlob(template) {
+	return node_path.default.normalize(template.replace(/\*/g, ""));
+}
+/** Removes a leading path separator, making the path relative. */
+function makeRelativePath(str) {
+	return str.startsWith(node_path.default.sep) ? str.slice(1) : str;
+}
+/** Computes a base path relative to the current working directory. */
+function getBasePath(relPath) {
+	return node_path.default.resolve(process.cwd(), relPath).replace(process.cwd() + node_path.default.sep, "").replace(process.cwd(), "");
+}
+//#endregion
+//#region src/file.ts
+var { readFile, writeFile } = node_fs_promises.default;
+/**
+* Resolves a config option that may be either a static value or a per-file function.
+* For function values, the file path is parsed through Handlebars before being passed.
+* @internal
+*/
+function getOptionValueForFile(config, filePath, fn, defaultValue) {
+	if (typeof fn !== "function") return defaultValue ?? fn;
+	return fn(filePath, node_path.default.dirname(handlebarsParse(config, filePath, { asPath: true }).toString()), node_path.default.basename(handlebarsParse(config, filePath, { asPath: true }).toString()));
+}
+/** Expands a list of glob patterns into a flat list of matching file paths. */
+async function getFileList(config, templates) {
+	log(config, LogLevel.debug, `Getting file list for glob list: ${templates}`);
+	return (await (0, glob.glob)(templates, {
+		dot: true,
+		nodir: true
+	})).map(node_path.default.normalize);
+}
+/** Analyzes a template path to determine if it's a glob, directory, or single file. */
+async function getTemplateGlobInfo(config, template) {
+	const _isGlob = (0, glob.hasMagic)(template);
+	log(config, LogLevel.debug, "before isDir", "isGlob:", _isGlob, template);
+	let resolvedTemplate = template;
+	let baseTemplatePath = _isGlob ? removeGlob(template) : template;
+	baseTemplatePath = node_path.default.normalize(baseTemplatePath);
+	const isDirOrGlob = _isGlob ? true : await isDir(template);
+	const shouldAddGlob = !_isGlob && isDirOrGlob;
+	log(config, LogLevel.debug, "after", {
+		isDirOrGlob,
+		shouldAddGlob
+	});
+	if (shouldAddGlob) resolvedTemplate = node_path.default.join(template, "**", "*");
+	return {
+		baseTemplatePath,
+		origTemplate: template,
+		isDirOrGlob,
+		isGlob: _isGlob,
+		template: resolvedTemplate
+	};
+}
+/** Computes the full output path and metadata for a single template file. */
+async function getTemplateFileInfo(config, { templatePath, basePath }) {
+	const inputPath = node_path.default.resolve(process.cwd(), templatePath);
+	const outputPathOpt = getOptionValueForFile(config, inputPath, config.output);
+	const outputDir = getOutputDir(config, outputPathOpt, basePath.replace(config.tmpDir, "./"));
+	const outputPath = handlebarsParse(config, node_path.default.join(outputDir, node_path.default.basename(inputPath)), { asPath: true }).toString();
+	return {
+		inputPath,
+		outputPathOpt,
+		outputDir,
+		outputPath,
+		exists: await pathExists(outputPath)
+	};
+}
+/**
+* Reads a template file, applies Handlebars parsing, runs the beforeWrite hook,
+* and writes the result to the output path.
+*/
+async function copyFileTransformed(config, { exists, overwrite, outputPath, inputPath }) {
+	if (!exists || overwrite) {
+		if (exists && overwrite) log(config, LogLevel.info, `File ${outputPath} exists, overwriting`);
+		log(config, LogLevel.debug, `Processing file ${inputPath}`);
+		const templateBuffer = await readFile(inputPath);
+		const unprocessedOutputContents = handlebarsParse(config, templateBuffer);
+		const finalOutputContents = await config.beforeWrite?.(unprocessedOutputContents, templateBuffer, outputPath) ?? unprocessedOutputContents;
+		if (!config.dryRun) await writeFile(outputPath, finalOutputContents);
+		else {
+			log(config, LogLevel.info, "Dry Run. Output should be:");
+			log(config, LogLevel.info, finalOutputContents.toString());
+		}
+	} else if (exists) log(config, LogLevel.info, `File ${outputPath} already exists, skipping`);
+	log(config, LogLevel.info, "Done.");
+}
+/** Computes the output directory for a file, combining the output path, base path, and optional subdir. */
+function getOutputDir(config, outputPathOpt, basePath) {
+	return node_path.default.resolve(process.cwd(), ...[
+		outputPathOpt,
+		basePath,
+		config.subdir ? config.subdirHelper ? handlebarsParse(config, `{{ ${config.subdirHelper} name }}`).toString() : config.name : void 0
+	].filter(Boolean));
+}
+/**
+* Processes a single template file: resolves output paths, creates directories,
+* and writes the transformed output.
+*/
+async function handleTemplateFile(config, { templatePath, basePath }) {
+	try {
+		const { inputPath, outputPathOpt, outputDir, outputPath, exists } = await getTemplateFileInfo(config, {
+			templatePath,
+			basePath
+		});
+		const overwrite = getOptionValueForFile(config, inputPath, config.overwrite ?? false);
+		log(config, LogLevel.debug, `\nParsing ${templatePath}`, `\nBase path: ${basePath}`, `\nFull input path: ${inputPath}`, `\nOutput Path Opt: ${outputPathOpt}`, `\nFull output dir: ${outputDir}`, `\nFull output path: ${outputPath}`, `\n`);
+		await createDirIfNotExists(node_path.default.dirname(outputPath), config);
+		log(config, LogLevel.info, `Writing to ${outputPath}`);
+		await copyFileTransformed(config, {
+			exists,
+			overwrite,
+			outputPath,
+			inputPath
+		});
+	} catch (e) {
+		handleErr(e);
+		throw e;
+	}
+}
+//#endregion
+//#region src/git.ts
+async function getGitConfig(url, file, tmpPath, logConfig) {
+	const repoUrl = `${url.protocol}//${url.host}${url.pathname}`;
+	log(logConfig, LogLevel.info, `Cloning git repo ${repoUrl}`);
+	return new Promise((res, reject) => {
+		log(logConfig, LogLevel.debug, `Cloning git repo to ${tmpPath}`);
+		const clone = (0, node_child_process.spawn)("git", [
+			"clone",
+			"--recurse-submodules",
+			"--depth",
+			"1",
+			repoUrl,
+			tmpPath
+		]);
+		clone.on("error", reject);
+		clone.on("close", async (code) => {
+			if (code === 0) {
+				res(await loadGitConfig({
+					logConfig,
+					url: repoUrl,
+					file,
+					tmpPath
+				}));
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`Git clone failed with code ${code}`));
+		});
+	});
+}
+/** @internal */
+async function loadGitConfig({ logConfig, url: repoUrl, file, tmpPath }) {
+	log(logConfig, LogLevel.info, `Loading config from git repo: ${repoUrl}`);
+	const filename = file || await findConfigFile(tmpPath);
+	const absolutePath = node_path.default.resolve(tmpPath, filename);
+	log(logConfig, LogLevel.debug, `Resolving config file: ${absolutePath}`);
+	const loadedConfig = await resolve(async () => (await import(absolutePath)).default, logConfig);
+	log(logConfig, LogLevel.info, `Loaded config from git`);
+	log(logConfig, LogLevel.debug, `Raw config:`, loadedConfig);
+	const fixedConfig = {};
+	for (const [k, v] of Object.entries(loadedConfig)) fixedConfig[k] = {
+		...v,
+		templates: v.templates.map((t) => node_path.default.resolve(tmpPath, t))
+	};
+	return wrapNoopResolver(fixedConfig);
+}
+//#endregion
+//#region src/before-write.ts
+/**
+* Wraps a CLI beforeWrite command string into a beforeWrite callback function.
+* The command receives the processed content via a temp file and can return modified content via stdout.
+* @internal
+*/
+function wrapBeforeWrite(config, beforeWrite) {
+	return async (content, rawContent, outputFile) => {
+		const tmpDir = node_path.default.join(getUniqueTmpPath(), node_path.default.basename(outputFile));
+		await createDirIfNotExists(node_path.default.dirname(tmpDir), config);
+		const ext = node_path.default.extname(outputFile);
+		const rawTmpPath = tmpDir.replace(ext, ".raw" + ext);
+		try {
+			log(config, LogLevel.debug, "Parsing beforeWrite command", beforeWrite);
+			const cmd = await prepareBeforeWriteCmd({
+				beforeWrite,
+				tmpDir,
+				content,
+				rawTmpPath,
+				rawContent
+			});
+			return await new Promise((resolve, reject) => {
+				log(config, LogLevel.debug, "Running parsed beforeWrite command:", cmd);
+				const proc = (0, node_child_process.exec)(cmd);
+				proc.stdout.on("data", (data) => {
+					if (data.trim()) resolve(data.toString());
+					else resolve(void 0);
+				});
+				proc.stderr.on("data", (data) => {
+					reject(data.toString());
+				});
+			});
+		} catch (e) {
+			log(config, LogLevel.debug, e);
+			log(config, LogLevel.warning, "Error running beforeWrite command, returning original content");
+			return;
+		} finally {
+			await node_fs_promises.default.rm(tmpDir, { force: true });
+			await node_fs_promises.default.rm(rawTmpPath, { force: true });
+		}
+	};
+}
+async function prepareBeforeWriteCmd({ beforeWrite, tmpDir, content, rawTmpPath, rawContent }) {
+	let cmd = "";
+	const pathReg = /\{\{\s*path\s*\}\}/gi;
+	const rawPathReg = /\{\{\s*rawpath\s*\}\}/gi;
+	if (pathReg.test(beforeWrite)) {
+		await node_fs_promises.default.writeFile(tmpDir, content);
+		cmd = beforeWrite.replaceAll(pathReg, tmpDir);
+	}
+	if (rawPathReg.test(beforeWrite)) {
+		await node_fs_promises.default.writeFile(rawTmpPath, rawContent);
+		cmd = beforeWrite.replaceAll(rawPathReg, rawTmpPath);
+	}
+	if (!cmd) {
+		await node_fs_promises.default.writeFile(tmpDir, content);
+		cmd = [beforeWrite, tmpDir].join(" ");
+	}
+	return cmd;
+}
+//#endregion
+//#region src/config.ts
+/** Parses CLI append-data syntax (`key=value` or `key:=jsonValue`) into a data object. @internal */
+function parseAppendData(value, options) {
+	const data = options.data ?? {};
+	const [key, val] = value.split(/:?=/);
+	if (value.includes(":=") && !val.includes(":=")) return {
+		...data,
+		[key]: JSON.parse(val)
+	};
+	return {
+		...data,
+		[key]: isWrappedWithQuotes(val) ? val.substring(1, val.length - 1) : val
+	};
+}
+function isWrappedWithQuotes(string) {
+	return string.startsWith("\"") && string.endsWith("\"") || string.startsWith("'") && string.endsWith("'");
+}
+/** Loads and resolves a config file (local or remote). @internal */
+async function getConfigFile(config) {
+	if (config.git && !config.git.includes("://")) {
+		log(config, LogLevel.info, `Loading config from GitHub ${config.git}`);
+		config.git = githubPartToUrl(config.git);
+	}
+	const isGit = Boolean(config.git);
+	const configFilename = config.config;
+	const configPath = isGit ? config.git : configFilename;
+	log(config, LogLevel.info, `Loading config from file ${configFilename}`);
+	let configImport = await resolve(await (isGit ? getRemoteConfig({
+		git: configPath,
+		config: configFilename,
+		logLevel: config.logLevel,
+		tmpDir: config.tmpDir
+	}) : getLocalConfig({
+		config: configFilename,
+		logLevel: config.logLevel
+	})), config);
+	if (typeof configImport.default === "function" || configImport.default instanceof Promise) {
+		log(config, LogLevel.debug, "Config is a function or promise, resolving...");
+		configImport = await resolve(configImport.default, config);
+	}
+	return configImport;
+}
+/**
+* Parses a CLI config into a full ScaffoldConfig by merging CLI args, config file values,
+* and append-data overrides. @internal
+*/
+async function parseConfigFile(config) {
+	let output = {
+		name: config.name,
+		templates: config.templates ?? [],
+		output: config.output,
+		logLevel: config.logLevel,
+		dryRun: config.dryRun,
+		data: config.data,
+		subdir: config.subdir,
+		overwrite: config.overwrite,
+		subdirHelper: config.subdirHelper,
+		beforeWrite: void 0,
+		tmpDir: config.tmpDir
+	};
+	if (config.quiet) config.logLevel = LogLevel.none;
+	if (Boolean(config.config || config.git)) {
+		const key = config.key ?? "default";
+		const configImport = await getConfigFile(config);
+		if (!configImport[key]) throw new Error(`Template "${key}" not found in ${config.config}`);
+		const imported = configImport[key];
+		log(config, LogLevel.debug, "Imported result", imported);
+		output = {
+			...output,
+			...imported,
+			beforeWrite: void 0,
+			templates: config.templates || imported.templates,
+			output: config.output || imported.output,
+			data: {
+				...imported.data,
+				...config.data
+			}
+		};
+	}
+	output.data = {
+		...output.data,
+		...config.appendData
+	};
+	const cmdBeforeWrite = config.beforeWrite ? wrapBeforeWrite(config, config.beforeWrite) : void 0;
+	output.beforeWrite = cmdBeforeWrite ?? output.beforeWrite;
+	if (!output.name) throw new Error("simple-scaffold: Missing required option: name");
+	log(output, LogLevel.debug, "Parsed config", output);
+	return output;
+}
+/** Converts a GitHub shorthand (user/repo) to a full HTTPS git URL. @internal */
+function githubPartToUrl(part) {
+	const gitUrl = new URL(`https://github.com/${part}`);
+	if (!gitUrl.pathname.endsWith(".git")) gitUrl.pathname += ".git";
+	return gitUrl.toString();
+}
+/** Loads a scaffold config from a local file or directory. @internal */
+async function getLocalConfig(config) {
+	const { config: configFile, ...logConfig } = config;
+	const absolutePath = node_path.default.resolve(process.cwd(), configFile);
+	if (await isDir(absolutePath)) {
+		log(logConfig, LogLevel.debug, `Resolving config file from directory ${absolutePath}`);
+		const file = await findConfigFile(absolutePath);
+		if (!await pathExists(file)) throw new Error(`Could not find config file in directory ${absolutePath}`);
+		log(logConfig, LogLevel.info, `Loading config from: ${node_path.default.resolve(absolutePath, file)}`);
+		return wrapNoopResolver(import(node_path.default.resolve(absolutePath, file)));
+	}
+	log(logConfig, LogLevel.info, `Loading config from: ${absolutePath}`);
+	return wrapNoopResolver(import(absolutePath));
+}
+/** Loads a scaffold config from a remote git repository. @internal */
+async function getRemoteConfig(config) {
+	const { config: configFile, git, tmpDir, ...logConfig } = config;
+	log(logConfig, LogLevel.info, `Loading config from remote ${git}, config file ${configFile || "<auto-detect>"}`);
+	const url = new URL(git);
+	const isHttp = url.protocol === "http:" || url.protocol === "https:";
+	if (!(url.protocol === "git:" || isHttp && url.pathname.endsWith(".git"))) throw new Error(`Unsupported protocol ${url.protocol}`);
+	return getGitConfig(url, configFile, tmpDir, logConfig);
+}
+/** Searches for a scaffold config file in the given directory, trying known filenames in order. @internal */
+async function findConfigFile(root) {
+	const allowed = [
+		"mjs",
+		"cjs",
+		"js",
+		"json"
+	].reduce((acc, ext) => {
+		acc.push(`scaffold.config.${ext}`);
+		acc.push(`scaffold.${ext}`);
+		acc.push(`.scaffold.${ext}`);
+		return acc;
+	}, []);
+	for (const file of allowed) if (await pathExists(node_path.default.resolve(root, file))) return file;
+	throw new Error(`Could not find config file in git repo`);
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/key.js
+var isUpKey = (key, keybindings = []) => key.name === "up" || keybindings.includes("vim") && key.name === "k" || keybindings.includes("emacs") && key.ctrl && key.name === "p";
+var isDownKey = (key, keybindings = []) => key.name === "down" || keybindings.includes("vim") && key.name === "j" || keybindings.includes("emacs") && key.ctrl && key.name === "n";
+var isBackspaceKey = (key) => key.name === "backspace";
+var isTabKey = (key) => key.name === "tab";
+var isNumberKey = (key) => "1234567890".includes(key.name);
+var isEnterKey = (key) => key.name === "enter" || key.name === "return";
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/errors.js
+var AbortPromptError = class extends Error {
+	name = "AbortPromptError";
+	message = "Prompt was aborted";
+	constructor(options) {
+		super();
+		this.cause = options?.cause;
+	}
+};
+var CancelPromptError = class extends Error {
+	name = "CancelPromptError";
+	message = "Prompt was canceled";
+};
+var ExitPromptError = class extends Error {
+	name = "ExitPromptError";
+};
+var HookError = class extends Error {
+	name = "HookError";
+};
+var ValidationError = class extends Error {
+	name = "ValidationError";
+};
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/hook-engine.js
+var hookStorage = new import___vite_browser_external.AsyncLocalStorage();
+function createStore(rl) {
+	return {
+		rl,
+		hooks: [],
+		hooksCleanup: [],
+		hooksEffect: [],
+		index: 0,
+		handleChange() {}
+	};
+}
+function withHooks(rl, cb) {
+	const store = createStore(rl);
+	return hookStorage.run(store, () => {
+		function cycle(render) {
+			store.handleChange = () => {
+				store.index = 0;
+				render();
+			};
+			store.handleChange();
+		}
+		return cb(cycle);
+	});
+}
+function getStore() {
+	const store = hookStorage.getStore();
+	if (!store) throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
+	return store;
+}
+function readline() {
+	return getStore().rl;
+}
+function withUpdates(fn) {
+	const wrapped = (...args) => {
+		const store = getStore();
+		let shouldUpdate = false;
+		const oldHandleChange = store.handleChange;
+		store.handleChange = () => {
+			shouldUpdate = true;
+		};
+		const returnValue = fn(...args);
+		if (shouldUpdate) oldHandleChange();
+		store.handleChange = oldHandleChange;
+		return returnValue;
+	};
+	return import___vite_browser_external.AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+	const store = getStore();
+	const { index } = store;
+	const returnValue = cb({
+		get() {
+			return store.hooks[index];
+		},
+		set(value) {
+			store.hooks[index] = value;
+		},
+		initialized: index in store.hooks
+	});
+	store.index++;
+	return returnValue;
+}
+function handleChange() {
+	getStore().handleChange();
+}
+var effectScheduler = {
+	queue(cb) {
+		const store = getStore();
+		const { index } = store;
+		store.hooksEffect.push(() => {
+			store.hooksCleanup[index]?.();
+			const cleanFn = cb(readline());
+			if (cleanFn != null && typeof cleanFn !== "function") throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+			store.hooksCleanup[index] = cleanFn;
+		});
+	},
+	run() {
+		const store = getStore();
+		withUpdates(() => {
+			store.hooksEffect.forEach((effect) => {
+				effect();
+			});
+			store.hooksEffect.length = 0;
+		})();
+	},
+	clearAll() {
+		const store = getStore();
+		store.hooksCleanup.forEach((cleanFn) => {
+			cleanFn?.();
+		});
+		store.hooksEffect.length = 0;
+		store.hooksCleanup.length = 0;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/use-state.js
+function useState(defaultValue) {
+	return withPointer((pointer) => {
+		const setState = import___vite_browser_external.AsyncResource.bind(function setState(newValue) {
+			if (pointer.get() !== newValue) {
+				pointer.set(newValue);
+				handleChange();
+			}
+		});
+		if (pointer.initialized) return [pointer.get(), setState];
+		const value = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+		pointer.set(value);
+		return [value, setState];
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/use-effect.js
+function useEffect(cb, depArray) {
+	withPointer((pointer) => {
+		const oldDeps = pointer.get();
+		if (!Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]))) effectScheduler.queue(cb);
+		pointer.set(depArray);
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+figures@2.0.4/node_modules/@inquirer/figures/dist/index.js
+function isUnicodeSupported() {
+	if (import___vite_browser_external.default.platform !== "win32") return import___vite_browser_external.default.env["TERM"] !== "linux";
+	return Boolean(import___vite_browser_external.default.env["WT_SESSION"]) || Boolean(import___vite_browser_external.default.env["TERMINUS_SUBLIME"]) || import___vite_browser_external.default.env["ConEmuTask"] === "{cmd::Cmder}" || import___vite_browser_external.default.env["TERM_PROGRAM"] === "Terminus-Sublime" || import___vite_browser_external.default.env["TERM_PROGRAM"] === "vscode" || import___vite_browser_external.default.env["TERM"] === "xterm-256color" || import___vite_browser_external.default.env["TERM"] === "alacritty" || import___vite_browser_external.default.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+var common = {
+	circleQuestionMark: "(?)",
+	questionMarkPrefix: "(?)",
+	square: "█",
+	squareDarkShade: "▓",
+	squareMediumShade: "▒",
+	squareLightShade: "░",
+	squareTop: "▀",
+	squareBottom: "▄",
+	squareLeft: "▌",
+	squareRight: "▐",
+	squareCenter: "■",
+	bullet: "●",
+	dot: "․",
+	ellipsis: "…",
+	pointerSmall: "›",
+	triangleUp: "▲",
+	triangleUpSmall: "▴",
+	triangleDown: "▼",
+	triangleDownSmall: "▾",
+	triangleLeftSmall: "◂",
+	triangleRightSmall: "▸",
+	home: "⌂",
+	heart: "♥",
+	musicNote: "♪",
+	musicNoteBeamed: "♫",
+	arrowUp: "↑",
+	arrowDown: "↓",
+	arrowLeft: "←",
+	arrowRight: "→",
+	arrowLeftRight: "↔",
+	arrowUpDown: "↕",
+	almostEqual: "≈",
+	notEqual: "≠",
+	lessOrEqual: "≤",
+	greaterOrEqual: "≥",
+	identical: "≡",
+	infinity: "∞",
+	subscriptZero: "₀",
+	subscriptOne: "₁",
+	subscriptTwo: "₂",
+	subscriptThree: "₃",
+	subscriptFour: "₄",
+	subscriptFive: "₅",
+	subscriptSix: "₆",
+	subscriptSeven: "₇",
+	subscriptEight: "₈",
+	subscriptNine: "₉",
+	oneHalf: "½",
+	oneThird: "⅓",
+	oneQuarter: "¼",
+	oneFifth: "⅕",
+	oneSixth: "⅙",
+	oneEighth: "⅛",
+	twoThirds: "⅔",
+	twoFifths: "⅖",
+	threeQuarters: "¾",
+	threeFifths: "⅗",
+	threeEighths: "⅜",
+	fourFifths: "⅘",
+	fiveSixths: "⅚",
+	fiveEighths: "⅝",
+	sevenEighths: "⅞",
+	line: "─",
+	lineBold: "━",
+	lineDouble: "═",
+	lineDashed0: "┄",
+	lineDashed1: "┅",
+	lineDashed2: "┈",
+	lineDashed3: "┉",
+	lineDashed4: "╌",
+	lineDashed5: "╍",
+	lineDashed6: "╴",
+	lineDashed7: "╶",
+	lineDashed8: "╸",
+	lineDashed9: "╺",
+	lineDashed10: "╼",
+	lineDashed11: "╾",
+	lineDashed12: "−",
+	lineDashed13: "–",
+	lineDashed14: "‐",
+	lineDashed15: "⁃",
+	lineVertical: "│",
+	lineVerticalBold: "┃",
+	lineVerticalDouble: "║",
+	lineVerticalDashed0: "┆",
+	lineVerticalDashed1: "┇",
+	lineVerticalDashed2: "┊",
+	lineVerticalDashed3: "┋",
+	lineVerticalDashed4: "╎",
+	lineVerticalDashed5: "╏",
+	lineVerticalDashed6: "╵",
+	lineVerticalDashed7: "╷",
+	lineVerticalDashed8: "╹",
+	lineVerticalDashed9: "╻",
+	lineVerticalDashed10: "╽",
+	lineVerticalDashed11: "╿",
+	lineDownLeft: "┐",
+	lineDownLeftArc: "╮",
+	lineDownBoldLeftBold: "┓",
+	lineDownBoldLeft: "┒",
+	lineDownLeftBold: "┑",
+	lineDownDoubleLeftDouble: "╗",
+	lineDownDoubleLeft: "╖",
+	lineDownLeftDouble: "╕",
+	lineDownRight: "┌",
+	lineDownRightArc: "╭",
+	lineDownBoldRightBold: "┏",
+	lineDownBoldRight: "┎",
+	lineDownRightBold: "┍",
+	lineDownDoubleRightDouble: "╔",
+	lineDownDoubleRight: "╓",
+	lineDownRightDouble: "╒",
+	lineUpLeft: "┘",
+	lineUpLeftArc: "╯",
+	lineUpBoldLeftBold: "┛",
+	lineUpBoldLeft: "┚",
+	lineUpLeftBold: "┙",
+	lineUpDoubleLeftDouble: "╝",
+	lineUpDoubleLeft: "╜",
+	lineUpLeftDouble: "╛",
+	lineUpRight: "└",
+	lineUpRightArc: "╰",
+	lineUpBoldRightBold: "┗",
+	lineUpBoldRight: "┖",
+	lineUpRightBold: "┕",
+	lineUpDoubleRightDouble: "╚",
+	lineUpDoubleRight: "╙",
+	lineUpRightDouble: "╘",
+	lineUpDownLeft: "┤",
+	lineUpBoldDownBoldLeftBold: "┫",
+	lineUpBoldDownBoldLeft: "┨",
+	lineUpDownLeftBold: "┥",
+	lineUpBoldDownLeftBold: "┩",
+	lineUpDownBoldLeftBold: "┪",
+	lineUpDownBoldLeft: "┧",
+	lineUpBoldDownLeft: "┦",
+	lineUpDoubleDownDoubleLeftDouble: "╣",
+	lineUpDoubleDownDoubleLeft: "╢",
+	lineUpDownLeftDouble: "╡",
+	lineUpDownRight: "├",
+	lineUpBoldDownBoldRightBold: "┣",
+	lineUpBoldDownBoldRight: "┠",
+	lineUpDownRightBold: "┝",
+	lineUpBoldDownRightBold: "┡",
+	lineUpDownBoldRightBold: "┢",
+	lineUpDownBoldRight: "┟",
+	lineUpBoldDownRight: "┞",
+	lineUpDoubleDownDoubleRightDouble: "╠",
+	lineUpDoubleDownDoubleRight: "╟",
+	lineUpDownRightDouble: "╞",
+	lineDownLeftRight: "┬",
+	lineDownBoldLeftBoldRightBold: "┳",
+	lineDownLeftBoldRightBold: "┯",
+	lineDownBoldLeftRight: "┰",
+	lineDownBoldLeftBoldRight: "┱",
+	lineDownBoldLeftRightBold: "┲",
+	lineDownLeftRightBold: "┮",
+	lineDownLeftBoldRight: "┭",
+	lineDownDoubleLeftDoubleRightDouble: "╦",
+	lineDownDoubleLeftRight: "╥",
+	lineDownLeftDoubleRightDouble: "╤",
+	lineUpLeftRight: "┴",
+	lineUpBoldLeftBoldRightBold: "┻",
+	lineUpLeftBoldRightBold: "┷",
+	lineUpBoldLeftRight: "┸",
+	lineUpBoldLeftBoldRight: "┹",
+	lineUpBoldLeftRightBold: "┺",
+	lineUpLeftRightBold: "┶",
+	lineUpLeftBoldRight: "┵",
+	lineUpDoubleLeftDoubleRightDouble: "╩",
+	lineUpDoubleLeftRight: "╨",
+	lineUpLeftDoubleRightDouble: "╧",
+	lineUpDownLeftRight: "┼",
+	lineUpBoldDownBoldLeftBoldRightBold: "╋",
+	lineUpDownBoldLeftBoldRightBold: "╈",
+	lineUpBoldDownLeftBoldRightBold: "╇",
+	lineUpBoldDownBoldLeftRightBold: "╊",
+	lineUpBoldDownBoldLeftBoldRight: "╉",
+	lineUpBoldDownLeftRight: "╀",
+	lineUpDownBoldLeftRight: "╁",
+	lineUpDownLeftBoldRight: "┽",
+	lineUpDownLeftRightBold: "┾",
+	lineUpBoldDownBoldLeftRight: "╂",
+	lineUpDownLeftBoldRightBold: "┿",
+	lineUpBoldDownLeftBoldRight: "╃",
+	lineUpBoldDownLeftRightBold: "╄",
+	lineUpDownBoldLeftBoldRight: "╅",
+	lineUpDownBoldLeftRightBold: "╆",
+	lineUpDoubleDownDoubleLeftDoubleRightDouble: "╬",
+	lineUpDoubleDownDoubleLeftRight: "╫",
+	lineUpDownLeftDoubleRightDouble: "╪",
+	lineCross: "╳",
+	lineBackslash: "╲",
+	lineSlash: "╱"
+};
+var specialMainSymbols = {
+	tick: "✔",
+	info: "ℹ",
+	warning: "⚠",
+	cross: "✘",
+	squareSmall: "◻",
+	squareSmallFilled: "◼",
+	circle: "◯",
+	circleFilled: "◉",
+	circleDotted: "◌",
+	circleDouble: "◎",
+	circleCircle: "ⓞ",
+	circleCross: "ⓧ",
+	circlePipe: "Ⓘ",
+	radioOn: "◉",
+	radioOff: "◯",
+	checkboxOn: "☒",
+	checkboxOff: "☐",
+	checkboxCircleOn: "ⓧ",
+	checkboxCircleOff: "Ⓘ",
+	pointer: "❯",
+	triangleUpOutline: "△",
+	triangleLeft: "◀",
+	triangleRight: "▶",
+	lozenge: "◆",
+	lozengeOutline: "◇",
+	hamburger: "☰",
+	smiley: "㋡",
+	mustache: "෴",
+	star: "★",
+	play: "▶",
+	nodejs: "⬢",
+	oneSeventh: "⅐",
+	oneNinth: "⅑",
+	oneTenth: "⅒"
+};
+var specialFallbackSymbols = {
+	tick: "√",
+	info: "i",
+	warning: "‼",
+	cross: "×",
+	squareSmall: "□",
+	squareSmallFilled: "■",
+	circle: "( )",
+	circleFilled: "(*)",
+	circleDotted: "( )",
+	circleDouble: "( )",
+	circleCircle: "(○)",
+	circleCross: "(×)",
+	circlePipe: "(│)",
+	radioOn: "(*)",
+	radioOff: "( )",
+	checkboxOn: "[×]",
+	checkboxOff: "[ ]",
+	checkboxCircleOn: "(×)",
+	checkboxCircleOff: "( )",
+	pointer: ">",
+	triangleUpOutline: "∆",
+	triangleLeft: "◄",
+	triangleRight: "►",
+	lozenge: "♦",
+	lozengeOutline: "◊",
+	hamburger: "≡",
+	smiley: "☺",
+	mustache: "┌─┐",
+	star: "✶",
+	play: "►",
+	nodejs: "♦",
+	oneSeventh: "1/7",
+	oneNinth: "1/9",
+	oneTenth: "1/10"
+};
+var mainSymbols = {
+	...common,
+	...specialMainSymbols
+};
+var fallbackSymbols = {
+	...common,
+	...specialFallbackSymbols
+};
+var figures = isUnicodeSupported() ? mainSymbols : fallbackSymbols;
+Object.entries(specialMainSymbols);
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/theme.js
+var defaultTheme = {
+	prefix: {
+		idle: (0, node_util.styleText)("blue", "?"),
+		done: (0, node_util.styleText)("green", figures.tick)
+	},
+	spinner: {
+		interval: 80,
+		frames: [
+			"⠋",
+			"⠙",
+			"⠹",
+			"⠸",
+			"⠼",
+			"⠴",
+			"⠦",
+			"⠧",
+			"⠇",
+			"⠏"
+		].map((frame) => (0, node_util.styleText)("yellow", frame))
+	},
+	style: {
+		answer: (text) => (0, node_util.styleText)("cyan", text),
+		message: (text) => (0, node_util.styleText)("bold", text),
+		error: (text) => (0, node_util.styleText)("red", `> ${text}`),
+		defaultAnswer: (text) => (0, node_util.styleText)("dim", `(${text})`),
+		help: (text) => (0, node_util.styleText)("dim", text),
+		highlight: (text) => (0, node_util.styleText)("cyan", text),
+		key: (text) => (0, node_util.styleText)("cyan", (0, node_util.styleText)("bold", `<${text}>`))
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/make-theme.js
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	let proto = value;
+	while (Object.getPrototypeOf(proto) !== null) proto = Object.getPrototypeOf(proto);
+	return Object.getPrototypeOf(value) === proto;
+}
+function deepMerge(...objects) {
+	const output = {};
+	for (const obj of objects) for (const [key, value] of Object.entries(obj)) {
+		const prevValue = output[key];
+		output[key] = isPlainObject(prevValue) && isPlainObject(value) ? deepMerge(prevValue, value) : value;
+	}
+	return output;
+}
+function makeTheme(...themes) {
+	return deepMerge(...[defaultTheme, ...themes.filter((theme) => theme != null)]);
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/use-prefix.js
+function usePrefix({ status = "idle", theme }) {
+	const [showLoader, setShowLoader] = useState(false);
+	const [tick, setTick] = useState(0);
+	const { prefix, spinner } = makeTheme(theme);
+	useEffect(() => {
+		if (status === "loading") {
+			let tickInterval;
+			let inc = -1;
+			const delayTimeout = setTimeout(() => {
+				setShowLoader(true);
+				tickInterval = setInterval(() => {
+					inc = inc + 1;
+					setTick(inc % spinner.frames.length);
+				}, spinner.interval);
+			}, 300);
+			return () => {
+				clearTimeout(delayTimeout);
+				clearInterval(tickInterval);
+			};
+		} else setShowLoader(false);
+	}, [status]);
+	if (showLoader) return spinner.frames[tick];
+	return typeof prefix === "string" ? prefix : prefix[status === "loading" ? "idle" : status] ?? prefix["idle"];
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/use-memo.js
+function useMemo(fn, dependencies) {
+	return withPointer((pointer) => {
+		const prev = pointer.get();
+		if (!prev || prev.dependencies.length !== dependencies.length || prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+			const value = fn();
+			pointer.set({
+				value,
+				dependencies
+			});
+			return value;
+		}
+		return prev.value;
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/use-ref.js
+function useRef(val) {
+	return useState({ current: val })[0];
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/use-keypress.js
+function useKeypress(userHandler) {
+	const signal = useRef(userHandler);
+	signal.current = userHandler;
+	useEffect((rl) => {
+		let ignore = false;
+		const handler = withUpdates((_input, event) => {
+			if (ignore) return;
+			signal.current(event, rl);
+		});
+		rl.input.on("keypress", handler);
+		return () => {
+			ignore = true;
+			rl.input.removeListener("keypress", handler);
+		};
+	}, []);
+}
+//#endregion
+//#region node_modules/.pnpm/cli-width@4.1.0/node_modules/cli-width/index.js
+var require_cli_width = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = cliWidth;
+	function normalizeOpts(options) {
+		const defaultOpts = {
+			defaultWidth: 0,
+			output: process.stdout,
+			tty: require___vite_browser_external()
+		};
+		if (!options) return defaultOpts;
+		Object.keys(defaultOpts).forEach(function(key) {
+			if (!options[key]) options[key] = defaultOpts[key];
+		});
+		return options;
+	}
+	function cliWidth(options) {
+		const opts = normalizeOpts(options);
+		if (opts.output.getWindowSize) return opts.output.getWindowSize()[0] || opts.defaultWidth;
+		if (opts.tty.getWindowSize) return opts.tty.getWindowSize()[1] || opts.defaultWidth;
+		if (opts.output.columns) return opts.output.columns;
+		if (process.env.CLI_WIDTH) {
+			const width = parseInt(process.env.CLI_WIDTH, 10);
+			if (!isNaN(width) && width !== 0) return width;
+		}
+		return opts.defaultWidth;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+	const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+	return (input) => {
+		let surrogatePairsNr = 0;
+		SURROGATE_PAIR_RE.lastIndex = 0;
+		while (SURROGATE_PAIR_RE.test(input)) surrogatePairsNr += 1;
+		return input.length - surrogatePairsNr;
+	};
+})();
+var isFullWidth = (x) => {
+	return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+	return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+//#endregion
+//#region node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/uy;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/uy;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION$1 = {
+	limit: Infinity,
+	ellipsis: ""
+};
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+	const LIMIT = truncationOptions.limit ?? Infinity;
+	const ELLIPSIS = truncationOptions.ellipsis ?? "";
+	const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION$1, widthOptions).width : 0);
+	const ANSI_WIDTH = 0;
+	const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+	const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+	const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+	const FULL_WIDTH_WIDTH = 2;
+	const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+	const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+	const PARSE_BLOCKS = [
+		[LATIN_RE, REGULAR_WIDTH],
+		[ANSI_RE, ANSI_WIDTH],
+		[CONTROL_RE, CONTROL_WIDTH],
+		[TAB_RE, TAB_WIDTH],
+		[EMOJI_RE, EMOJI_WIDTH],
+		[CJKT_WIDE_RE, WIDE_WIDTH]
+	];
+	let indexPrev = 0;
+	let index = 0;
+	let length = input.length;
+	let lengthExtra = 0;
+	let truncationEnabled = false;
+	let truncationIndex = length;
+	let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+	let unmatchedStart = 0;
+	let unmatchedEnd = 0;
+	let width = 0;
+	let widthExtra = 0;
+	outer: while (true) {
+		if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+			const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+			lengthExtra = 0;
+			for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+				const codePoint = char.codePointAt(0) || 0;
+				if (isFullWidth(codePoint)) widthExtra = FULL_WIDTH_WIDTH;
+				else if (isWideNotCJKTNotEmoji(codePoint)) widthExtra = WIDE_WIDTH;
+				else widthExtra = REGULAR_WIDTH;
+				if (width + widthExtra > truncationLimit) truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+				if (width + widthExtra > LIMIT) {
+					truncationEnabled = true;
+					break outer;
+				}
+				lengthExtra += char.length;
+				width += widthExtra;
+			}
+			unmatchedStart = unmatchedEnd = 0;
+		}
+		if (index >= length) break outer;
+		for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+			const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+			BLOCK_RE.lastIndex = index;
+			if (BLOCK_RE.test(input)) {
+				lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+				widthExtra = lengthExtra * BLOCK_WIDTH;
+				if (width + widthExtra > truncationLimit) truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+				if (width + widthExtra > LIMIT) {
+					truncationEnabled = true;
+					break outer;
+				}
+				width += widthExtra;
+				unmatchedStart = indexPrev;
+				unmatchedEnd = index;
+				index = indexPrev = BLOCK_RE.lastIndex;
+				continue outer;
+			}
+		}
+		index += 1;
+	}
+	return {
+		width: truncationEnabled ? truncationLimit : width,
+		index: truncationEnabled ? truncationIndex : length,
+		truncated: truncationEnabled,
+		ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+	};
+};
+//#endregion
+//#region node_modules/.pnpm/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION = {
+	limit: Infinity,
+	ellipsis: "",
+	ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+	return getStringTruncatedWidth(input, NO_TRUNCATION, options).width;
+};
+//#endregion
+//#region node_modules/.pnpm/fast-wrap-ansi@0.2.0/node_modules/fast-wrap-ansi/lib/main.js
+var ESC$1 = "\x1B";
+var CSI = "›";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+	if (openingCode >= 30 && openingCode <= 37) return 39;
+	if (openingCode >= 90 && openingCode <= 97) return 39;
+	if (openingCode >= 40 && openingCode <= 47) return 49;
+	if (openingCode >= 100 && openingCode <= 107) return 49;
+	if (openingCode === 1 || openingCode === 2) return 22;
+	if (openingCode === 3) return 23;
+	if (openingCode === 4) return 24;
+	if (openingCode === 7) return 27;
+	if (openingCode === 8) return 28;
+	if (openingCode === 9) return 29;
+	if (openingCode === 0) return 0;
+};
+var wrapAnsiCode = (code) => `${ESC$1}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC$1}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+	const characters = word[Symbol.iterator]();
+	let isInsideEscape = false;
+	let isInsideLinkEscape = false;
+	let lastRow = rows.at(-1);
+	let visible = lastRow === void 0 ? 0 : fastStringWidth(lastRow);
+	let currentCharacter = characters.next();
+	let nextCharacter = characters.next();
+	let rawCharacterIndex = 0;
+	while (!currentCharacter.done) {
+		const character = currentCharacter.value;
+		const characterLength = fastStringWidth(character);
+		if (visible + characterLength <= columns) rows[rows.length - 1] += character;
+		else {
+			rows.push(character);
+			visible = 0;
+		}
+		if (character === ESC$1 || character === CSI) {
+			isInsideEscape = true;
+			isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+		}
+		if (isInsideEscape) {
+			if (isInsideLinkEscape) {
+				if (character === ANSI_ESCAPE_BELL) {
+					isInsideEscape = false;
+					isInsideLinkEscape = false;
+				}
+			} else if (character === ANSI_SGR_TERMINATOR) isInsideEscape = false;
+		} else {
+			visible += characterLength;
+			if (visible === columns && !nextCharacter.done) {
+				rows.push("");
+				visible = 0;
+			}
+		}
+		currentCharacter = nextCharacter;
+		nextCharacter = characters.next();
+		rawCharacterIndex += character.length;
+	}
+	lastRow = rows.at(-1);
+	if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) rows[rows.length - 2] += rows.pop();
+};
+var stringVisibleTrimSpacesRight = (string) => {
+	const words = string.split(" ");
+	let last = words.length;
+	while (last) {
+		if (fastStringWidth(words[last - 1])) break;
+		last--;
+	}
+	if (last === words.length) return string;
+	return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+	if (options.trim !== false && string.trim() === "") return "";
+	let returnValue = "";
+	let escapeCode;
+	let escapeUrl;
+	const words = string.split(" ");
+	let rows = [""];
+	let rowLength = 0;
+	for (let index = 0; index < words.length; index++) {
+		const word = words[index];
+		if (options.trim !== false) {
+			const row = rows.at(-1) ?? "";
+			const trimmed = row.trimStart();
+			if (row.length !== trimmed.length) {
+				rows[rows.length - 1] = trimmed;
+				rowLength = fastStringWidth(trimmed);
+			}
+		}
+		if (index !== 0) {
+			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+				rows.push("");
+				rowLength = 0;
+			}
+			if (rowLength || options.trim === false) {
+				rows[rows.length - 1] += " ";
+				rowLength++;
+			}
+		}
+		const wordLength = fastStringWidth(word);
+		if (options.hard && wordLength > columns) {
+			const remainingColumns = columns - rowLength;
+			const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+			if (Math.floor((wordLength - 1) / columns) < breaksStartingThisLine) rows.push("");
+			wrapWord(rows, word, columns);
+			rowLength = fastStringWidth(rows.at(-1) ?? "");
+			continue;
+		}
+		if (rowLength + wordLength > columns && rowLength && wordLength) {
+			if (options.wordWrap === false && rowLength < columns) {
+				wrapWord(rows, word, columns);
+				rowLength = fastStringWidth(rows.at(-1) ?? "");
+				continue;
+			}
+			rows.push("");
+			rowLength = 0;
+		}
+		if (rowLength + wordLength > columns && options.wordWrap === false) {
+			wrapWord(rows, word, columns);
+			rowLength = fastStringWidth(rows.at(-1) ?? "");
+			continue;
+		}
+		rows[rows.length - 1] += word;
+		rowLength += wordLength;
+	}
+	if (options.trim !== false) rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+	const preString = rows.join("\n");
+	let inSurrogate = false;
+	for (let i = 0; i < preString.length; i++) {
+		const character = preString[i];
+		returnValue += character;
+		if (!inSurrogate) {
+			inSurrogate = character >= "\ud800" && character <= "\udbff";
+			if (inSurrogate) continue;
+		} else inSurrogate = false;
+		if (character === ESC$1 || character === CSI) {
+			GROUP_REGEX.lastIndex = i + 1;
+			const groups = GROUP_REGEX.exec(preString)?.groups;
+			if (groups?.code !== void 0) {
+				const code = Number.parseFloat(groups.code);
+				escapeCode = code === END_CODE ? void 0 : code;
+			} else if (groups?.uri !== void 0) escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+		}
+		if (preString[i + 1] === "\n") {
+			if (escapeUrl) returnValue += wrapAnsiHyperlink("");
+			const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+			if (escapeCode && closingCode) returnValue += wrapAnsiCode(closingCode);
+		} else if (character === "\n") {
+			if (escapeCode && getClosingCode(escapeCode)) returnValue += wrapAnsiCode(escapeCode);
+			if (escapeUrl) returnValue += wrapAnsiHyperlink(escapeUrl);
+		}
+	}
+	return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+	return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/utils.js
+var import_cli_width = /* @__PURE__ */ __toESM(require_cli_width(), 1);
+/**
+* Force line returns at specific width. This function is ANSI code friendly and it'll
+* ignore invisible codes during width calculation.
+* @param {string} content
+* @param {number} width
+* @return {string}
+*/
+function breakLines(content, width) {
+	return content.split("\n").flatMap((line) => wrapAnsi(line, width, {
+		trim: false,
+		hard: true
+	}).split("\n").map((str) => str.trimEnd())).join("\n");
+}
+/**
+* Returns the width of the active readline, or 80 as default value.
+* @returns {number}
+*/
+function readlineWidth() {
+	return (0, import_cli_width.default)({
+		defaultWidth: 80,
+		output: readline().output
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
+function usePointerPosition({ active, renderedItems, pageSize, loop }) {
+	const state = useRef({
+		lastPointer: active,
+		lastActive: void 0
+	});
+	const { lastPointer, lastActive } = state.current;
+	const middle = Math.floor(pageSize / 2);
+	const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+	const defaultPointerPosition = renderedItems.slice(0, active).reduce((acc, item) => acc + item.length, 0);
+	let pointer = defaultPointerPosition;
+	if (renderedLength > pageSize) if (loop) {
+		/**
+		* Creates the next position for the pointer considering an infinitely
+		* looping list of items to be rendered on the page.
+		*
+		* The goal is to progressively move the cursor to the middle position as the user move down, and then keep
+		* the cursor there. When the user move up, maintain the cursor position.
+		*/
+		pointer = lastPointer;
+		if (lastActive != null && lastActive < active && active - lastActive < pageSize) pointer = Math.min(middle, Math.abs(active - lastActive) === 1 ? Math.min(lastPointer + (renderedItems[lastActive]?.length ?? 0), Math.max(defaultPointerPosition, lastPointer)) : lastPointer + active - lastActive);
+	} else {
+		/**
+		* Creates the next position for the pointer considering a finite list of
+		* items to be rendered on a page.
+		*
+		* The goal is to keep the pointer in the middle of the page whenever possible, until
+		* we reach the bounds of the list (top or bottom). In which case, the cursor moves progressively
+		* to the bottom or top of the list.
+		*/
+		const spaceUnderActive = renderedItems.slice(active).reduce((acc, item) => acc + item.length, 0);
+		pointer = spaceUnderActive < pageSize - middle ? pageSize - spaceUnderActive : Math.min(defaultPointerPosition, middle);
+	}
+	state.current.lastPointer = pointer;
+	state.current.lastActive = active;
+	return pointer;
+}
+function usePagination({ items, active, renderItem, pageSize, loop = true }) {
+	const width = readlineWidth();
+	const bound = (num) => (num % items.length + items.length) % items.length;
+	const renderedItems = items.map((item, index) => {
+		if (item == null) return [];
+		return breakLines(renderItem({
+			item,
+			index,
+			isActive: index === active
+		}), width).split("\n");
+	});
+	const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+	const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+	const pointer = usePointerPosition({
+		active,
+		renderedItems,
+		pageSize,
+		loop
+	});
+	const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+	const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+	const pageBuffer = Array.from({ length: pageSize });
+	pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+	const itemVisited = new Set([active]);
+	let bufferPointer = activeItemPosition + activeItem.length;
+	let itemPointer = bound(active + 1);
+	while (bufferPointer < pageSize && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+		const linesToAdd = renderItemAtIndex(itemPointer).slice(0, pageSize - bufferPointer);
+		pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+		itemVisited.add(itemPointer);
+		bufferPointer += linesToAdd.length;
+		itemPointer = bound(itemPointer + 1);
+	}
+	bufferPointer = activeItemPosition - 1;
+	itemPointer = bound(active - 1);
+	while (bufferPointer >= 0 && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+		const lines = renderItemAtIndex(itemPointer);
+		const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+		pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+		itemVisited.add(itemPointer);
+		bufferPointer -= linesToAdd.length;
+		itemPointer = bound(itemPointer - 1);
+	}
+	return pageBuffer.filter((line) => typeof line === "string").join("\n");
+}
+//#endregion
+//#region node_modules/.pnpm/mute-stream@3.0.0/node_modules/mute-stream/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stream = require___vite_browser_external();
+	var MuteStream = class extends Stream {
+		#isTTY = null;
+		constructor(opts = {}) {
+			super(opts);
+			this.writable = this.readable = true;
+			this.muted = false;
+			this.on("pipe", this._onpipe);
+			this.replace = opts.replace;
+			this._prompt = opts.prompt || null;
+			this._hadControl = false;
+		}
+		#destSrc(key, def) {
+			if (this._dest) return this._dest[key];
+			if (this._src) return this._src[key];
+			return def;
+		}
+		#proxy(method, ...args) {
+			if (typeof this._dest?.[method] === "function") this._dest[method](...args);
+			if (typeof this._src?.[method] === "function") this._src[method](...args);
+		}
+		get isTTY() {
+			if (this.#isTTY !== null) return this.#isTTY;
+			return this.#destSrc("isTTY", false);
+		}
+		set isTTY(val) {
+			this.#isTTY = val;
+		}
+		get rows() {
+			return this.#destSrc("rows");
+		}
+		get columns() {
+			return this.#destSrc("columns");
+		}
+		mute() {
+			this.muted = true;
+		}
+		unmute() {
+			this.muted = false;
+		}
+		_onpipe(src) {
+			this._src = src;
+		}
+		pipe(dest, options) {
+			this._dest = dest;
+			return super.pipe(dest, options);
+		}
+		pause() {
+			if (this._src) return this._src.pause();
+		}
+		resume() {
+			if (this._src) return this._src.resume();
+		}
+		write(c) {
+			if (this.muted) {
+				if (!this.replace) return true;
+				if (c.match(/^\u001b/)) {
+					if (c.indexOf(this._prompt) === 0) {
+						c = c.slice(this._prompt.length);
+						c = c.replace(/./g, this.replace);
+						c = this._prompt + c;
+					}
+					this._hadControl = true;
+					return this.emit("data", c);
+				} else {
+					if (this._prompt && this._hadControl && c.indexOf(this._prompt) === 0) {
+						this._hadControl = false;
+						this.emit("data", this._prompt);
+						c = c.slice(this._prompt.length);
+					}
+					c = c.toString().replace(/./g, this.replace);
+				}
+			}
+			this.emit("data", c);
+		}
+		end(c) {
+			if (this.muted) if (c && this.replace) c = c.toString().replace(/./g, this.replace);
+			else c = null;
+			if (c) this.emit("data", c);
+			this.emit("end");
+		}
+		destroy(...args) {
+			return this.#proxy("destroy", ...args);
+		}
+		destroySoon(...args) {
+			return this.#proxy("destroySoon", ...args);
+		}
+		close(...args) {
+			return this.#proxy("close", ...args);
+		}
+	};
+	module.exports = MuteStream;
+}));
+//#endregion
+//#region node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+/**
+* This is not the set of all possible signals.
+*
+* It IS, however, the set of all signals that trigger
+* an exit on either Linux or BSD systems.  Linux is a
+* superset of the signal names supported on BSD, and
+* the unknown signals just fail to register, so we can
+* catch that easily enough.
+*
+* Windows signals are a different set, since there are
+* signals that terminate Windows processes, but don't
+* terminate (or don't even exist) on Posix systems.
+*
+* Don't bother with SIGKILL.  It's uncatchable, which
+* means that we can't fire any callbacks anyway.
+*
+* If a user does happen to register a handler on a non-
+* fatal signal like SIGWINCH or something, and then
+* exit, it'll end up firing `process.emit('exit')`, so
+* the handler will be fired anyway.
+*
+* SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+* artificially, inherently leave the process in a
+* state from which it is not safe to try and enter JS
+* listeners.
+*/
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+if (process.platform === "linux") signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+//#endregion
+//#region node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process) => !!process && typeof process === "object" && typeof process.removeListener === "function" && typeof process.emit === "function" && typeof process.reallyExit === "function" && typeof process.listeners === "function" && typeof process.kill === "function" && typeof process.pid === "number" && typeof process.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+	emitted = {
+		afterExit: false,
+		exit: false
+	};
+	listeners = {
+		afterExit: [],
+		exit: []
+	};
+	count = 0;
+	id = Math.random();
+	constructor() {
+		if (global[kExitEmitter]) return global[kExitEmitter];
+		ObjectDefineProperty(global, kExitEmitter, {
+			value: this,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+	on(ev, fn) {
+		this.listeners[ev].push(fn);
+	}
+	removeListener(ev, fn) {
+		const list = this.listeners[ev];
+		const i = list.indexOf(fn);
+		/* c8 ignore start */
+		if (i === -1) return;
+		/* c8 ignore stop */
+		if (i === 0 && list.length === 1) list.length = 0;
+		else list.splice(i, 1);
+	}
+	emit(ev, code, signal) {
+		if (this.emitted[ev]) return false;
+		this.emitted[ev] = true;
+		let ret = false;
+		for (const fn of this.listeners[ev]) ret = fn(code, signal) === true || ret;
+		if (ev === "exit") ret = this.emit("afterExit", code, signal) || ret;
+		return ret;
+	}
+};
+var SignalExitBase = class {};
+var signalExitWrap = (handler) => {
+	return {
+		onExit(cb, opts) {
+			return handler.onExit(cb, opts);
+		},
+		load() {
+			return handler.load();
+		},
+		unload() {
+			return handler.unload();
+		}
+	};
+};
+var SignalExitFallback = class extends SignalExitBase {
+	onExit() {
+		return () => {};
+	}
+	load() {}
+	unload() {}
+};
+var SignalExit = class extends SignalExitBase {
+	/* c8 ignore start */
+	#hupSig = process$1.platform === "win32" ? "SIGINT" : "SIGHUP";
+	/* c8 ignore stop */
+	#emitter = new Emitter();
+	#process;
+	#originalProcessEmit;
+	#originalProcessReallyExit;
+	#sigListeners = {};
+	#loaded = false;
+	constructor(process) {
+		super();
+		this.#process = process;
+		this.#sigListeners = {};
+		for (const sig of signals) this.#sigListeners[sig] = () => {
+			const listeners = this.#process.listeners(sig);
+			let { count } = this.#emitter;
+			/* c8 ignore start */
+			const p = process;
+			if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") count += p.__signal_exit_emitter__.count;
+			/* c8 ignore stop */
+			if (listeners.length === count) {
+				this.unload();
+				const ret = this.#emitter.emit("exit", null, sig);
+				/* c8 ignore start */
+				const s = sig === "SIGHUP" ? this.#hupSig : sig;
+				if (!ret) process.kill(process.pid, s);
+			}
+		};
+		this.#originalProcessReallyExit = process.reallyExit;
+		this.#originalProcessEmit = process.emit;
+	}
+	onExit(cb, opts) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return () => {};
+		/* c8 ignore stop */
+		if (this.#loaded === false) this.load();
+		const ev = opts?.alwaysLast ? "afterExit" : "exit";
+		this.#emitter.on(ev, cb);
+		return () => {
+			this.#emitter.removeListener(ev, cb);
+			if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) this.unload();
+		};
+	}
+	load() {
+		if (this.#loaded) return;
+		this.#loaded = true;
+		this.#emitter.count += 1;
+		for (const sig of signals) try {
+			const fn = this.#sigListeners[sig];
+			if (fn) this.#process.on(sig, fn);
+		} catch (_) {}
+		this.#process.emit = (ev, ...a) => {
+			return this.#processEmit(ev, ...a);
+		};
+		this.#process.reallyExit = (code) => {
+			return this.#processReallyExit(code);
+		};
+	}
+	unload() {
+		if (!this.#loaded) return;
+		this.#loaded = false;
+		signals.forEach((sig) => {
+			const listener = this.#sigListeners[sig];
+			/* c8 ignore start */
+			if (!listener) throw new Error("Listener not defined for signal: " + sig);
+			/* c8 ignore stop */
+			try {
+				this.#process.removeListener(sig, listener);
+			} catch (_) {}
+			/* c8 ignore stop */
+		});
+		this.#process.emit = this.#originalProcessEmit;
+		this.#process.reallyExit = this.#originalProcessReallyExit;
+		this.#emitter.count -= 1;
+	}
+	#processReallyExit(code) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return 0;
+		this.#process.exitCode = code || 0;
+		/* c8 ignore stop */
+		this.#emitter.emit("exit", this.#process.exitCode, null);
+		return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+	}
+	#processEmit(ev, ...args) {
+		const og = this.#originalProcessEmit;
+		if (ev === "exit" && processOk(this.#process)) {
+			if (typeof args[0] === "number") this.#process.exitCode = args[0];
+			/* c8 ignore start */
+			const ret = og.call(this.#process, ev, ...args);
+			/* c8 ignore start */
+			this.#emitter.emit("exit", this.#process.exitCode, null);
+			/* c8 ignore stop */
+			return ret;
+		} else return og.call(this.#process, ev, ...args);
+	}
+};
+var process$1 = globalThis.process;
+var { onExit, load, unload } = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
+//#endregion
+//#region node_modules/.pnpm/@inquirer+ansi@2.0.4/node_modules/@inquirer/ansi/dist/index.js
+var ESC = "\x1B[";
+ESC + "";
+/** Hide the cursor */
+var cursorHide = ESC + "?25l";
+/** Show the cursor */
+var cursorShow = ESC + "?25h";
+/** Move cursor up by count rows */
+var cursorUp = (rows = 1) => rows > 0 ? `${ESC}${rows}A` : "";
+/** Move cursor down by count rows */
+var cursorDown = (rows = 1) => rows > 0 ? `${ESC}${rows}B` : "";
+/** Move cursor to position (x, y) */
+var cursorTo = (x, y) => {
+	if (typeof y === "number" && !Number.isNaN(y)) return `${ESC}${y + 1};${x + 1}H`;
+	return `${ESC}${x + 1}G`;
+};
+var eraseLine = ESC + "2K";
+/** Erase the specified number of lines above the cursor */
+var eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + "\x1B[G" : "";
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/screen-manager.js
+var height = (content) => content.split("\n").length;
+var lastLine = (content) => content.split("\n").pop() ?? "";
+var ScreenManager = class {
+	height = 0;
+	extraLinesUnderPrompt = 0;
+	cursorPos;
+	rl;
+	constructor(rl) {
+		this.rl = rl;
+		this.cursorPos = rl.getCursorPos();
+	}
+	write(content) {
+		this.rl.output.unmute();
+		this.rl.output.write(content);
+		this.rl.output.mute();
+	}
+	render(content, bottomContent = "") {
+		const rawPromptLine = (0, node_util.stripVTControlCharacters)(lastLine(content));
+		let prompt = rawPromptLine;
+		if (this.rl.line.length > 0) prompt = prompt.slice(0, -this.rl.line.length);
+		this.rl.setPrompt(prompt);
+		this.cursorPos = this.rl.getCursorPos();
+		const width = readlineWidth();
+		content = breakLines(content, width);
+		bottomContent = breakLines(bottomContent, width);
+		if (rawPromptLine.length % width === 0) content += "\n";
+		let output = content + (bottomContent ? "\n" + bottomContent : "");
+		const bottomContentHeight = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows + (bottomContent ? height(bottomContent) : 0);
+		if (bottomContentHeight > 0) output += cursorUp(bottomContentHeight);
+		output += cursorTo(this.cursorPos.cols);
+		/**
+		* Render and store state for future re-rendering
+		*/
+		this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+		this.extraLinesUnderPrompt = bottomContentHeight;
+		this.height = height(output);
+	}
+	checkCursorPos() {
+		const cursorPos = this.rl.getCursorPos();
+		if (cursorPos.cols !== this.cursorPos.cols) {
+			this.write(cursorTo(cursorPos.cols));
+			this.cursorPos = cursorPos;
+		}
+	}
+	done({ clearContent }) {
+		this.rl.setPrompt("");
+		let output = cursorDown(this.extraLinesUnderPrompt);
+		output += clearContent ? eraseLines(this.height) : "\n";
+		output += cursorShow;
+		this.write(output);
+		this.rl.close();
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/promise-polyfill.js
+var PromisePolyfill = class extends Promise {
+	static withResolver() {
+		let resolve;
+		let reject;
+		return {
+			promise: new Promise((res, rej) => {
+				resolve = res;
+				reject = rej;
+			}),
+			resolve,
+			reject
+		};
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/create-prompt.js
+var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
+var nativeSetImmediate = globalThis.setImmediate;
+function getCallSites() {
+	const _prepareStackTrace = Error.prepareStackTrace;
+	let result = [];
+	try {
+		Error.prepareStackTrace = (_, callSites) => {
+			const callSitesWithoutCurrent = callSites.slice(1);
+			result = callSitesWithoutCurrent;
+			return callSitesWithoutCurrent;
+		};
+		(/* @__PURE__ */ new Error()).stack;
+	} catch {
+		return result;
+	}
+	Error.prepareStackTrace = _prepareStackTrace;
+	return result;
+}
+function createPrompt(view) {
+	const callSites = getCallSites();
+	const prompt = (config, context = {}) => {
+		const { input = process.stdin, signal } = context;
+		const cleanups = /* @__PURE__ */ new Set();
+		const output = new import_lib.default();
+		output.pipe(context.output ?? process.stdout);
+		output.mute();
+		const rl = import___vite_browser_external.createInterface({
+			terminal: true,
+			input,
+			output
+		});
+		const screen = new ScreenManager(rl);
+		const { promise, resolve, reject } = PromisePolyfill.withResolver();
+		const cancel = () => reject(new CancelPromptError());
+		if (signal) {
+			const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
+			if (signal.aborted) {
+				abort();
+				return Object.assign(promise, { cancel });
+			}
+			signal.addEventListener("abort", abort);
+			cleanups.add(() => signal.removeEventListener("abort", abort));
+		}
+		cleanups.add(onExit((code, signal) => {
+			reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal}`));
+		}));
+		const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
+		rl.on("SIGINT", sigint);
+		cleanups.add(() => rl.removeListener("SIGINT", sigint));
+		return withHooks(rl, (cycle) => {
+			const hooksCleanup = import___vite_browser_external.AsyncResource.bind(() => effectScheduler.clearAll());
+			rl.on("close", hooksCleanup);
+			cleanups.add(() => rl.removeListener("close", hooksCleanup));
+			const startCycle = () => {
+				const checkCursorPos = () => screen.checkCursorPos();
+				rl.input.on("keypress", checkCursorPos);
+				cleanups.add(() => rl.input.removeListener("keypress", checkCursorPos));
+				cycle(() => {
+					try {
+						const nextView = view(config, (value) => {
+							setImmediate(() => resolve(value));
+						});
+						if (nextView === void 0) {
+							const callerFilename = callSites[1]?.getFileName();
+							throw new Error(`Prompt functions must return a string.\n    at ${callerFilename}`);
+						}
+						const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
+						screen.render(content, bottomContent);
+						effectScheduler.run();
+					} catch (error) {
+						reject(error);
+					}
+				});
+			};
+			if ("readableFlowing" in input) nativeSetImmediate(startCycle);
+			else startCycle();
+			return Object.assign(promise.then((answer) => {
+				effectScheduler.clearAll();
+				return answer;
+			}, (error) => {
+				effectScheduler.clearAll();
+				throw error;
+			}).finally(() => {
+				cleanups.forEach((cleanup) => cleanup());
+				screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+				output.end();
+			}).then(() => promise), { cancel });
+		});
+	};
+	return prompt;
+}
+//#endregion
+//#region node_modules/.pnpm/@inquirer+core@11.1.7_@types+node@25.5.0/node_modules/@inquirer/core/dist/lib/Separator.js
+/**
+* Separator object
+* Used to space/separate choices group
+*/
+var Separator = class {
+	separator = (0, node_util.styleText)("dim", Array.from({ length: 15 }).join(figures.line));
+	type = "separator";
+	constructor(separator) {
+		if (separator) this.separator = separator;
+	}
+	static isSeparator(choice) {
+		return Boolean(choice && typeof choice === "object" && "type" in choice && choice.type === "separator");
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@inquirer+input@5.0.10_@types+node@25.5.0/node_modules/@inquirer/input/dist/index.js
+var inputTheme = { validationFailureMode: "keep" };
+var dist_default$1 = createPrompt((config, done) => {
+	const { prefill = "tab" } = config;
+	const theme = makeTheme(inputTheme, config.theme);
+	const [status, setStatus] = useState("idle");
+	const [defaultValue, setDefaultValue] = useState(String(config.default ?? ""));
+	const [errorMsg, setError] = useState();
+	const [value, setValue] = useState("");
+	const prefix = usePrefix({
+		status,
+		theme
+	});
+	async function validate(value) {
+		const { required, pattern, patternError = "Invalid input" } = config;
+		if (required && !value) return "You must provide a value";
+		if (pattern && !pattern.test(value)) return patternError;
+		if (typeof config.validate === "function") return await config.validate(value) || "You must provide a valid value";
+		return true;
+	}
+	useKeypress(async (key, rl) => {
+		if (status !== "idle") return;
+		if (isEnterKey(key)) {
+			const answer = value || defaultValue;
+			setStatus("loading");
+			const isValid = await validate(answer);
+			if (isValid === true) {
+				setValue(answer);
+				setStatus("done");
+				done(answer);
+			} else {
+				if (theme.validationFailureMode === "clear") setValue("");
+				else rl.write(value);
+				setError(isValid);
+				setStatus("idle");
+			}
+		} else if (isBackspaceKey(key) && !value) setDefaultValue("");
+		else if (isTabKey(key) && !value) {
+			setDefaultValue("");
+			rl.clearLine(0);
+			rl.write(defaultValue);
+			setValue(defaultValue);
+		} else {
+			setValue(rl.line);
+			setError(void 0);
+		}
+	});
+	useEffect((rl) => {
+		if (prefill === "editable" && defaultValue) {
+			rl.write(defaultValue);
+			setValue(defaultValue);
+		}
+	}, []);
+	const message = theme.style.message(config.message, status);
+	let formattedValue = value;
+	if (typeof config.transformer === "function") formattedValue = config.transformer(value, { isFinal: status === "done" });
+	else if (status === "done") formattedValue = theme.style.answer(value);
+	let defaultStr;
+	if (defaultValue && status !== "done" && !value) defaultStr = theme.style.defaultAnswer(defaultValue);
+	let error = "";
+	if (errorMsg) error = theme.style.error(errorMsg);
+	return [[
+		prefix,
+		message,
+		defaultStr,
+		formattedValue
+	].filter((v) => v !== void 0).join(" "), error];
+});
+//#endregion
+//#region node_modules/.pnpm/@inquirer+select@5.1.2_@types+node@25.5.0/node_modules/@inquirer/select/dist/index.js
+var selectTheme = {
+	icon: { cursor: figures.pointer },
+	style: {
+		disabled: (text) => (0, node_util.styleText)("dim", text),
+		description: (text) => (0, node_util.styleText)("cyan", text),
+		keysHelpTip: (keys) => keys.map(([key, action]) => `${(0, node_util.styleText)("bold", key)} ${(0, node_util.styleText)("dim", action)}`).join((0, node_util.styleText)("dim", " • "))
+	},
+	i18n: { disabledError: "This option is disabled and cannot be selected." },
+	indexMode: "hidden",
+	keybindings: []
+};
+function isSelectable(item) {
+	return !Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+	return !Separator.isSeparator(item);
+}
+function normalizeChoices(choices) {
+	return choices.map((choice) => {
+		if (Separator.isSeparator(choice)) return choice;
+		if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+			const name = String(choice);
+			return {
+				value: choice,
+				name,
+				short: name,
+				disabled: false
+			};
+		}
+		const name = choice.name ?? String(choice.value);
+		const normalizedChoice = {
+			value: choice.value,
+			name,
+			short: choice.short ?? name,
+			disabled: choice.disabled ?? false
+		};
+		if (choice.description) normalizedChoice.description = choice.description;
+		return normalizedChoice;
+	});
+}
+var dist_default = createPrompt((config, done) => {
+	const { loop = true, pageSize = 7 } = config;
+	const theme = makeTheme(selectTheme, config.theme);
+	const { keybindings } = theme;
+	const [status, setStatus] = useState("idle");
+	const prefix = usePrefix({
+		status,
+		theme
+	});
+	const searchTimeoutRef = useRef();
+	const searchEnabled = !keybindings.includes("vim");
+	const items = useMemo(() => normalizeChoices(config.choices), [config.choices]);
+	const bounds = useMemo(() => {
+		const first = items.findIndex(isNavigable);
+		const last = items.findLastIndex(isNavigable);
+		if (first === -1) throw new ValidationError("[select prompt] No selectable choices. All choices are disabled.");
+		return {
+			first,
+			last
+		};
+	}, [items]);
+	const defaultItemIndex = useMemo(() => {
+		if (!("default" in config)) return -1;
+		return items.findIndex((item) => isSelectable(item) && item.value === config.default);
+	}, [config.default, items]);
+	const [active, setActive] = useState(defaultItemIndex === -1 ? bounds.first : defaultItemIndex);
+	const selectedChoice = items[active];
+	const [errorMsg, setError] = useState();
+	useKeypress((key, rl) => {
+		clearTimeout(searchTimeoutRef.current);
+		if (errorMsg) setError(void 0);
+		if (isEnterKey(key)) if (selectedChoice.disabled) setError(theme.i18n.disabledError);
+		else {
+			setStatus("done");
+			done(selectedChoice.value);
+		}
+		else if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+			rl.clearLine(0);
+			if (loop || isUpKey(key, keybindings) && active !== bounds.first || isDownKey(key, keybindings) && active !== bounds.last) {
+				const offset = isUpKey(key, keybindings) ? -1 : 1;
+				let next = active;
+				do
+					next = (next + offset + items.length) % items.length;
+				while (!isNavigable(items[next]));
+				setActive(next);
+			}
+		} else if (isNumberKey(key) && !Number.isNaN(Number(rl.line))) {
+			const selectedIndex = Number(rl.line) - 1;
+			let selectableIndex = -1;
+			const position = items.findIndex((item) => {
+				if (Separator.isSeparator(item)) return false;
+				selectableIndex++;
+				return selectableIndex === selectedIndex;
+			});
+			const item = items[position];
+			if (item != null && isSelectable(item)) setActive(position);
+			searchTimeoutRef.current = setTimeout(() => {
+				rl.clearLine(0);
+			}, 700);
+		} else if (isBackspaceKey(key)) rl.clearLine(0);
+		else if (searchEnabled) {
+			const searchTerm = rl.line.toLowerCase();
+			const matchIndex = items.findIndex((item) => {
+				if (Separator.isSeparator(item) || !isSelectable(item)) return false;
+				return item.name.toLowerCase().startsWith(searchTerm);
+			});
+			if (matchIndex !== -1) setActive(matchIndex);
+			searchTimeoutRef.current = setTimeout(() => {
+				rl.clearLine(0);
+			}, 700);
+		}
+	});
+	useEffect(() => () => {
+		clearTimeout(searchTimeoutRef.current);
+	}, []);
+	const message = theme.style.message(config.message, status);
+	const helpLine = theme.style.keysHelpTip([["↑↓", "navigate"], ["⏎", "select"]]);
+	let separatorCount = 0;
+	const page = usePagination({
+		items,
+		active,
+		renderItem({ item, isActive, index }) {
+			if (Separator.isSeparator(item)) {
+				separatorCount++;
+				return ` ${item.separator}`;
+			}
+			const cursor = isActive ? theme.icon.cursor : " ";
+			const indexLabel = theme.indexMode === "number" ? `${index + 1 - separatorCount}. ` : "";
+			if (item.disabled) {
+				const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+				const disabledCursor = isActive ? theme.icon.cursor : "-";
+				return theme.style.disabled(`${disabledCursor} ${indexLabel}${item.name} ${disabledLabel}`);
+			}
+			return (isActive ? theme.style.highlight : (x) => x)(`${cursor} ${indexLabel}${item.name}`);
+		},
+		pageSize,
+		loop
+	});
+	if (status === "done") return [
+		prefix,
+		message,
+		theme.style.answer(selectedChoice.short)
+	].filter(Boolean).join(" ");
+	const { description } = selectedChoice;
+	return `${[
+		[prefix, message].filter(Boolean).join(" "),
+		page,
+		" ",
+		description ? theme.style.description(description) : "",
+		errorMsg ? theme.style.error(errorMsg) : "",
+		helpLine
+	].filter(Boolean).join("\n").trimEnd()}${cursorHide}`;
+});
+//#endregion
+//#region src/prompts.ts
+/** Prompts the user for a scaffold name. */
+async function promptForName() {
+	return dist_default$1({
+		message: colorize.cyan("Scaffold name:"),
+		required: true,
+		validate: (value) => {
+			if (!value.trim()) return "Name cannot be empty";
+			return true;
+		}
+	});
+}
+/** Prompts the user to select a template key from the available config keys. */
+async function promptForTemplateKey(configMap) {
+	const keys = Object.keys(configMap);
+	if (keys.length === 0) throw new Error("No templates found in config file");
+	if (keys.length === 1) return keys[0];
+	return dist_default({
+		message: colorize.cyan("Select a template:"),
+		choices: keys.map((key) => ({
+			name: key,
+			value: key
+		}))
+	});
+}
+/** Prompts the user for an output directory path. */
+async function promptForOutput() {
+	return dist_default$1({
+		message: colorize.cyan("Output directory:"),
+		required: true,
+		default: ".",
+		validate: (value) => {
+			if (!value.trim()) return "Output directory cannot be empty";
+			return true;
+		}
+	});
+}
+/** Prompts the user for template paths (comma-separated). */
+async function promptForTemplates() {
+	return (await dist_default$1({
+		message: colorize.cyan("Template paths (comma-separated):"),
+		required: true,
+		validate: (value) => {
+			if (!value.trim()) return "At least one template path is required";
+			return true;
+		}
+	})).split(",").map((t) => t.trim()).filter(Boolean);
+}
+/**
+* Prompts the user for any required scaffold inputs that are not already provided in data.
+* Also applies default values for optional inputs that have one.
+* Returns the merged data object.
+*/
+async function promptForInputs(inputs, existingData = {}) {
+	const data = { ...existingData };
+	for (const [key, def] of Object.entries(inputs)) {
+		if (key in data && data[key] !== void 0 && data[key] !== "") continue;
+		if (def.required) data[key] = await dist_default$1({
+			message: colorize.cyan(def.message ?? `${key}:`),
+			required: true,
+			default: def.default,
+			validate: (value) => {
+				if (!value.trim()) return `${key} is required`;
+				return true;
+			}
+		});
+		else if (def.default !== void 0 && !(key in data)) data[key] = def.default;
+	}
+	return data;
+}
+/** Returns true if the process is running in an interactive terminal. */
+function isInteractive() {
+	return Boolean(process.stdin.isTTY);
+}
+/**
+* Fills in missing config values by prompting the user interactively.
+* Only prompts when running in a TTY — in non-interactive mode, returns config as-is.
+*/
+async function promptForMissingConfig(config, configMap) {
+	if (!isInteractive()) return config;
+	if (!config.name) config.name = await promptForName();
+	if (configMap && !config.key) {
+		if (Object.keys(configMap).length > 1) config.key = await promptForTemplateKey(configMap);
+	}
+	if (!config.output) config.output = await promptForOutput();
+	if (!config.templates || config.templates.length === 0) config.templates = await promptForTemplates();
+	return config;
+}
+/**
+* Prompts for any required inputs defined in the scaffold config and merges them into data.
+* Only prompts in interactive mode; in non-interactive mode, only applies defaults.
+*/
+async function resolveInputs(config) {
+	if (!config.inputs) return config;
+	if (isInteractive()) config.data = await promptForInputs(config.inputs, config.data);
+	else {
+		const data = { ...config.data };
+		for (const [key, def] of Object.entries(config.inputs)) if (def.default !== void 0 && !(key in data)) data[key] = def.default;
+		config.data = data;
+	}
+	return config;
+}
+//#endregion
+//#region src/scaffold.ts
+/**
+* @module
+* Simple Scaffold
+*
+* See [readme](README.md)
+*/
+/**
+* Create a scaffold using given `options`.
+*
+* #### Create files
+* To create a file structure to output, use any directory and file structure you would like.
+* Inside folder names, file names or file contents, you may place `{{ var }}` where `var` is either
+* `name` which is the scaffold name you provided or one of the keys you provided in the `data` option.
+*
+* The contents and names will be replaced with the transformed values so you can use your original structure as a
+* boilerplate for other projects, components, modules, or even single files.
+*
+* The files will maintain their structure, starting from the directory containing the template (or the template itself
+* if it is already a directory), and will output from that directory into the directory defined by `config.output`.
+*
+* #### Helpers
+* Helpers are functions you can use to transform your `{{ var }}` contents into other values without having to
+* pre-define the data and use a duplicated key.
+*
+* Any functions you provide in `helpers` option will also be available to you to make custom formatting as you see fit
+* (for example, formatting a date)
+*
+* For available default values, see {@link DefaultHelpers}.
+*
+* @param {ScaffoldConfig} config The main configuration object
+* @return {Promise<void>} A promise that resolves when the scaffold is complete
+*
+* @see {@link DefaultHelpers}
+* @see {@link CaseHelpers}
+* @see {@link DateHelpers}
+*
+* @category Main
+*/
+async function Scaffold(config) {
+	config.output ??= process.cwd();
+	config = await resolveInputs(config);
+	registerHelpers(config);
+	try {
+		config.data = {
+			name: config.name,
+			...config.data
+		};
+		logInitStep(config);
+		const excludes = config.templates.filter((t) => t.startsWith("!"));
+		const includes = config.templates.filter((t) => !t.startsWith("!"));
+		const templates = await resolveTemplateGlobs(config, includes);
+		for (const tpl of templates) await processTemplateGlob(config, tpl, excludes);
+	} catch (e) {
+		log(config, LogLevel.error, e);
+		throw e;
+	}
+}
+/** Resolves included template paths into GlobInfo objects. */
+async function resolveTemplateGlobs(config, includes) {
+	const templates = [];
+	for (const includedTemplate of includes) try {
+		templates.push(await getTemplateGlobInfo(config, includedTemplate));
+	} catch (e) {
+		handleErr(e);
+	}
+	return templates;
+}
+/** Processes all files matching a single template glob pattern. */
+async function processTemplateGlob(config, tpl, excludes) {
+	const files = await getFileList(config, [tpl.template, ...excludes]);
+	for (const file of files) {
+		if (await isDir(file)) continue;
+		log(config, LogLevel.debug, "Iterating files", {
+			files,
+			file
+		});
+		const relPath = makeRelativePath(node_path.default.dirname(removeGlob(file).replace(tpl.baseTemplatePath, "")));
+		const basePath = getBasePath(relPath);
+		log(config, LogLevel.debug, {
+			originalTemplate: tpl.origTemplate,
+			relativePath: relPath,
+			parsedTemplate: tpl.template,
+			inputFilePath: file,
+			baseTemplatePath: tpl.baseTemplatePath,
+			basePath,
+			isDirOrGlob: tpl.isDirOrGlob,
+			isGlob: tpl.isGlob
+		});
+		await handleTemplateFile(config, {
+			templatePath: file,
+			basePath
+		});
+	}
+}
+/**
+* Create a scaffold based on a config file or URL.
+*
+* @param {string} pathOrUrl The path or URL to the config file
+* @param {Record<string, string>} config Information needed before loading the config
+* @param {Partial<Omit<ScaffoldConfig, 'name'>>} overrides Any overrides to the loaded config
+*
+* @see {@link Scaffold}
+* @category Main
+* @return {Promise<void>} A promise that resolves when the scaffold is complete
+*/
+Scaffold.fromConfig = async function(pathOrUrl, config, overrides) {
+	const tmpPath = node_path.default.resolve(node_os.default.tmpdir(), `scaffold-config-${Date.now()}`);
+	const _cmdConfig = {
+		dryRun: false,
+		output: process.cwd(),
+		logLevel: LogLevel.info,
+		overwrite: false,
+		templates: [],
+		subdir: false,
+		quiet: false,
+		config: pathOrUrl,
+		version: false,
+		tmpDir: tmpPath,
+		...config
+	};
+	const _overrides = resolve(overrides, _cmdConfig);
+	return Scaffold({
+		...await parseConfigFile(_cmdConfig),
+		..._overrides
+	});
+};
+//#endregion
+Object.defineProperty(exports, "LogLevel", {
+	enumerable: true,
+	get: function() {
+		return LogLevel;
+	}
+});
+Object.defineProperty(exports, "Scaffold", {
+	enumerable: true,
+	get: function() {
+		return Scaffold;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "colorize", {
+	enumerable: true,
+	get: function() {
+		return colorize;
+	}
+});
+Object.defineProperty(exports, "findConfigFile", {
+	enumerable: true,
+	get: function() {
+		return findConfigFile;
+	}
+});
+Object.defineProperty(exports, "getConfigFile", {
+	enumerable: true,
+	get: function() {
+		return getConfigFile;
+	}
+});
+Object.defineProperty(exports, "getUniqueTmpPath", {
+	enumerable: true,
+	get: function() {
+		return getUniqueTmpPath;
+	}
+});
+Object.defineProperty(exports, "log", {
+	enumerable: true,
+	get: function() {
+		return log;
+	}
+});
+Object.defineProperty(exports, "parseAppendData", {
+	enumerable: true,
+	get: function() {
+		return parseAppendData;
+	}
+});
+Object.defineProperty(exports, "parseConfigFile", {
+	enumerable: true,
+	get: function() {
+		return parseConfigFile;
+	}
+});
+Object.defineProperty(exports, "promptForMissingConfig", {
+	enumerable: true,
+	get: function() {
+		return promptForMissingConfig;
+	}
+});
+Object.defineProperty(exports, "resolveInputs", {
+	enumerable: true,
+	get: function() {
+		return resolveInputs;
+	}
+});
+
+//# sourceMappingURL=scaffold-Ce-rIwy9.js.map