@i18n-micro/cli 0.0.0-stage → 2.0.0

package/dist/chunks/http-whB7a5ye.mjs

@@ -0,0 +1,100 @@
+import { F as urlParts, h as CliError } from "./json-BV_apCMu.mjs";
+// src/http.ts
+var RETRYABLE = /* @__PURE__ */ new Set([
+	408,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+/** A POST is a billed translation: after anything else it may have run, so it is not sent twice. */
+var NOT_PROCESSED = /* @__PURE__ */ new Set([429, 503]);
+/** Asked to wait longer, a run has hit a quota, not a hiccup: it fails instead of sleeping in silence. */
+var MAX_WAIT_MS = 6e4;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** What a URL may show in an error: query strings carry API keys (`?key=`). */
+function safeUrl(url) {
+	const { scheme, host } = urlParts(url);
+	return scheme + host;
+}
+function messageFromBody(body) {
+	try {
+		const parsed = JSON.parse(body);
+		const nested = parsed.error?.message;
+		const found = [
+			parsed.message,
+			nested,
+			parsed.error,
+			parsed.error_msg,
+			parsed.errorMessage
+		].find((value) => typeof value === "string");
+		if (found) return found;
+	} catch {}
+	return body.slice(0, 300);
+}
+function httpError(response, url, body) {
+	const hints = response.status === 401 || response.status === 403 ? ["Check the API token and its permissions."] : response.status === 429 ? ["Rate limit reached: lower --chunkSize or set --options retries:5,retryDelayMs:2000."] : [];
+	return new CliError(messageFromBody(body) || `HTTP ${response.status}`, {
+		code: "HTTP_ERROR",
+		hints,
+		details: {
+			"HTTP status": String(response.status),
+			URL: safeUrl(url)
+		}
+	});
+}
+var retryAfterMs = (response) => {
+	const seconds = Number(response.headers.get("retry-after"));
+	return Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : null;
+};
+async function attempt(url, options, retriesLeft, delayMs) {
+	const { timeoutMs = 3e4, retries: _retries, retryDelayMs: _delay, ...init } = options;
+	const once = init.method === "POST";
+	let response;
+	try {
+		response = await fetch(url, {
+			...init,
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch (error) {
+		if (!once && retriesLeft > 0) {
+			await sleep(delayMs);
+			return attempt(url, options, retriesLeft - 1, delayMs * 2);
+		}
+		const scrub = (text) => text.replaceAll(url, safeUrl(url));
+		const reason = [error.message, error.cause?.message].filter(Boolean).join(": ");
+		const cause = new Error(scrub(reason));
+		throw new CliError(`Request failed: ${cause.message}`, {
+			code: "HTTP_ERROR",
+			details: { URL: safeUrl(url) },
+			cause
+		});
+	}
+	if (response.ok) return response;
+	const asked = retryAfterMs(response);
+	if ((once ? NOT_PROCESSED : RETRYABLE).has(response.status) && retriesLeft > 0 && (asked ?? 0) <= MAX_WAIT_MS) {
+		await sleep(asked ?? delayMs);
+		return attempt(url, options, retriesLeft - 1, delayMs * 2);
+	}
+	throw httpError(response, url, await response.text());
+}
+var request = (url, options = {}) => attempt(url, options, options.retries ?? 2, options.retryDelayMs ?? 500);
+async function requestJson(url, options = {}) {
+	const text = await (await request(url, options)).text();
+	if (text === "") return void 0;
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw new CliError("The service did not return JSON.", {
+			code: "HTTP_ERROR",
+			details: { URL: safeUrl(url) },
+			cause: error
+		});
+	}
+}
+var jsonBody = (value) => ({
+	body: JSON.stringify(value),
+	headers: { "Content-Type": "application/json" }
+});
+export { requestJson as n, jsonBody as t };

package/dist/chunks/import-CnL8U6Za.mjs

@@ -0,0 +1,99 @@
+import { a as parseCsv, i as parsePo, n as readManifest, t as defaultExchangeDir } from "./export-C2J-pagB.mjs";
+import { A as log, M as plural, S as validationError, _ as findingsError, j as pick, v as notFoundError } from "./json-BV_apCMu.mjs";
+import { c as readText, m as walkFiles, u as relativePath } from "./nuxt-dKxG087V.mjs";
+import { t as Project } from "./project-DgWgr7pF.mjs";
+import { existsSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+// src/commands/import.ts
+/** Only where `export` puts a catalog: a backup in a subfolder must not land on the global file. */
+function poScope(file, dir) {
+	const parts = relativePath(dir, dirname(file)).split("/").filter(Boolean);
+	if (parts.length === 0) return "";
+	if (parts[0] === "pages" && parts.length > 1) return parts.slice(1).join("/");
+	throw validationError(`Not a place for a catalog: ${relativePath(dir, file)}`, ["Expected <locale>.po or pages/<page>/<locale>.po."]);
+}
+/** A page's catalog the last export did not write: the page is gone, and importing would bring it back. */
+function assertExported(file, dir, exported) {
+	const name = relativePath(dir, file);
+	if (exported.length === 0 || exported.includes(name)) return;
+	throw validationError(`Not part of the last export: ${name}`, ["Delete the file, or restore the page and export again."]);
+}
+function readPo(project, dir) {
+	const files = walkFiles(dir, (path) => path.endsWith(".po"));
+	if (files.length === 0) throw notFoundError(`No PO files in ${dir}`);
+	const exported = Object.keys(readManifest(dir)).filter((name) => name.endsWith(".po"));
+	return files.flatMap((file) => {
+		const code = basename(file, ".po");
+		if (!project.codes.includes(code)) {
+			log.warn(`Skipping ${file}: ${code} is not a configured locale.`);
+			return [];
+		}
+		const { messages, fuzzy } = parsePo(readText(file));
+		const guesses = Object.keys(fuzzy);
+		if (guesses.length > 0) log.warn(`Skipping ${plural(guesses.length, "fuzzy entry", "fuzzy entries")} in ${file}: ${guesses.join(", ")}`);
+		const scope = poScope(file, dir);
+		if (scope !== "") assertExported(file, dir, exported);
+		return Object.entries(messages).map(([key, value]) => ({
+			code,
+			scope,
+			key,
+			value
+		}));
+	});
+}
+/** The column has to name this locale: a row of another one would land in the wrong file. */
+function csvScope(file, code, path) {
+	const name = file.replaceAll("\\", "/");
+	if (name === `${code}.json`) return "";
+	const slash = name.lastIndexOf("/");
+	if (name.startsWith("pages/") && slash >= 7 && name.slice(slash + 1) === `${code}.json`) return name.slice(6, slash);
+	throw validationError(`Row of another file in ${path}: ${file}`, [`Expected ${code}.json or pages/<page>/${code}.json.`]);
+}
+function csvColumns(header, path) {
+	const columns = {
+		file: header?.indexOf("File") ?? -1,
+		key: header?.indexOf("Key") ?? -1,
+		translation: header?.indexOf("Translation") ?? -1
+	};
+	if (Object.values(columns).includes(-1)) throw validationError(`Malformed header in ${path}: expected File, Key and Translation columns`);
+	return columns;
+}
+function readCsvFile(path, code) {
+	const [header, ...rows] = parseCsv(readText(path), path);
+	const columns = csvColumns(header, path);
+	return rows.map((row) => {
+		const [file, key, value] = [
+			row[columns.file],
+			row[columns.key],
+			row[columns.translation]
+		];
+		if (!file || !key || value === void 0) throw validationError(`Malformed row in ${path}: ${row.join(",")}`);
+		return {
+			code,
+			scope: csvScope(file, code, path),
+			key,
+			value
+		};
+	});
+}
+function readCsv(project, dir) {
+	const present = project.codes.filter((code) => existsSync(join(dir, `${code}.csv`)));
+	if (present.length === 0) throw notFoundError(`No CSV files in ${dir}`);
+	return present.flatMap((code) => readCsvFile(join(dir, `${code}.csv`), code));
+}
+async function run(args) {
+	const project = await Project.load(args);
+	const dir = resolve(project.config.rootDir, args.dir ?? defaultExchangeDir(args.format));
+	const filled = (args.format === "csv" ? readCsv(project, dir) : readPo(project, dir)).filter((entry) => entry.value !== "");
+	if (project.config.disablePageLocales && filled.some((entry) => entry.scope !== "")) throw validationError("disablePageLocales is on: the app would never read page translations.", ["Remove the page entries, or turn the option off."]);
+	const conflicts = filled.flatMap(({ code, scope, key, value }) => {
+		const conflict = project.locale(code).set(key, value, scope);
+		return conflict ? [`${code} ${key}: ${conflict} already holds a value`] : [];
+	});
+	const imported = filled.length - conflicts.length;
+	if (!args.dryRun) project.save();
+	log.list("Not imported", conflicts);
+	log.success(`${args.dryRun ? "Dry run: would import" : "Imported"} ${plural(imported, "translation")}.`);
+	if (conflicts.length > 0) throw findingsError(`${plural(conflicts.length, "entry", "entries")} ${pick(conflicts.length, "was", "were")} not imported.`, ["Rename the key or remove the value that blocks it."]);
+}
+export { run as default };

package/dist/chunks/info-rYas4Yw3.mjs

@@ -0,0 +1,32 @@
+import { t as version } from "./package-f9OTcDxl.mjs";
+import { A as log } from "./json-BV_apCMu.mjs";
+import { t as loadProjectConfig } from "./nuxt-dKxG087V.mjs";
+// src/commands/info.ts
+async function run(args) {
+	const config = await loadProjectConfig(args.cwd ?? ".");
+	const locales = config.locales.map((locale) => locale.code);
+	const { rootDir, srcDir, defaultLocale, translationDir, translationDirs, disablePageLocales } = config;
+	if (args.json) {
+		log.json({
+			version,
+			rootDir,
+			srcDir,
+			defaultLocale,
+			locales,
+			translationDir,
+			translationDirs,
+			disablePageLocales
+		});
+		return;
+	}
+	log.rows([
+		["CLI", version],
+		["Root", rootDir],
+		["Default locale", defaultLocale],
+		["Locales", locales.join(", ")],
+		["Translation directory", translationDir],
+		["Page locales", disablePageLocales ? "disabled" : "enabled"]
+	]);
+	log.list("Read from, last wins", translationDirs);
+}
+export { run as default };

package/dist/chunks/json-BV_apCMu.mjs

@@ -0,0 +1,439 @@
+import { createInterface } from "node:readline";
+import { stripVTControlCharacters } from "node:util";
+// src/log.ts
+var silent = false;
+var secrets = /* @__PURE__ */ new Set();
+/** Anything printed from now on shows `***` instead. Shorter than a real key, it would only garble the text. */
+function addSecret(value) {
+	if (!value || value.length < 4) return;
+	secrets.add(value);
+	secrets.add(encodeURIComponent(value));
+}
+/**
+* A URL up to its query, split around the last `@` there: one in the query is no part of the address.
+* Not a `.*` regex: that stops at a line end and leaves the password in the text.
+*/
+function urlParts(url) {
+	const end = url.search(/[?#;]/);
+	const address = end === -1 ? url : url.slice(0, end);
+	const at = address.lastIndexOf("@");
+	if (at === -1) return {
+		scheme: "",
+		host: address
+	};
+	const slashes = address.indexOf("://");
+	const start = slashes === -1 || slashes > at ? 0 : slashes + 3;
+	return {
+		scheme: address.slice(0, start),
+		credentials: address.slice(start, at),
+		host: address.slice(at + 1)
+	};
+}
+/** A URL somebody typed: what is after its path and before its host can be a key, whatever a server echoes back. */
+function addUrlSecrets(url) {
+	if (!url) return;
+	const [, ...tail] = url.split(/[?#;&]/);
+	for (const pair of tail) addSecret(pair.slice(pair.indexOf("=") + 1));
+	const { credentials } = urlParts(url);
+	if (!credentials) return;
+	addSecret(credentials);
+	const colon = credentials.indexOf(":");
+	addSecret(colon === -1 ? credentials : credentials.slice(0, colon));
+	if (colon !== -1) addSecret(credentials.slice(colon + 1));
+}
+var URL_CREDENTIALS = /(\/\/)[^/\s]+@/g;
+/** The address first and the longest secret first: a part replaced earlier would leave the rest of a longer one in view. */
+var redact = (text) => [...secrets].sort((a, b) => b.length - a.length).reduce((out, secret) => out.replaceAll(secret, "***"), text.replace(URL_CREDENTIALS, "$1***@"));
+var env = process.env;
+/** A live terminal: a pipe or a CI log gets no header, spinner or timing, so its text stays the same run after run. */
+var isInteractive = (stream = process.stdout) => Boolean(stream.isTTY) && !env.CI;
+/** `hasColors` exists on terminals only, and answers NO_COLOR, FORCE_COLOR and TERM=dumb. */
+var hasColors = (stream) => Boolean(stream.isTTY && stream.hasColors?.());
+/** The symbols of @clack/prompts, which nuxi prints its log lines with. */
+var symbols = !(process.platform === "win32" && process.stdout.isTTY && !env.WT_SESSION && !env.TERM_PROGRAM) ? {
+	info: "●",
+	success: "◆",
+	warn: "▲",
+	error: "■",
+	step: "◇",
+	arrow: "→",
+	frames: [
+		"◒",
+		"◐",
+		"◓",
+		"◑"
+	]
+} : {
+	info: "•",
+	success: "*",
+	warn: "!",
+	error: "x",
+	step: "o",
+	arrow: ">",
+	frames: [
+		"|",
+		"/",
+		"-",
+		"\\"
+	]
+};
+var SGR = {
+	bold: [1, 22],
+	dim: [2, 22],
+	underline: [4, 24],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	blue: [34, 39],
+	magenta: [35, 39],
+	cyan: [36, 39],
+	gray: [90, 39],
+	black: [30, 39],
+	bgRed: [41, 49],
+	bgYellow: [43, 49]
+};
+/** Always styled: the writer strips it again for a stream without colors. */
+var style = (names, text) => [names].flat().reduce((out, name) => `\u001B[${SGR[name][0]}m${out}\u001B[${SGR[name][1]}m`, text);
+var indentLines = (text) => text.replaceAll("\n", "\n  ");
+/** Columns padded to the widest cell; the last one is not. The first is the subject, the third on is context. */
+function columns(rows) {
+	const widths = rows[0]?.map((_cell, index) => Math.max(...rows.map((row) => row[index]?.length ?? 0))) ?? [];
+	const tone = (index, cell) => index === 0 ? style("cyan", cell) : index >= 2 ? style("gray", cell) : cell;
+	return rows.map((row) => row.map((cell, index) => tone(index, index === row.length - 1 ? cell : cell.padEnd(widths[index]))).join("  "));
+}
+var frame = 0;
+var label = "";
+var timer;
+/** A frame is on the screen, on the line the next output would start on. */
+var drawn = false;
+var drawSpinner = () => {
+	const glyph = symbols.frames[frame++ % symbols.frames.length];
+	process.stderr.write(`\r\u001B[2K${hasColors(process.stderr) ? style("magenta", glyph) : glyph} ${label}...`);
+	drawn = true;
+};
+/** On stderr, and on a live terminal only: stdout stays clean for `--json` and pipes. */
+var spinner = {
+	start(text) {
+		if (silent || !isInteractive(process.stderr)) return;
+		label = text;
+		timer ??= setInterval(drawSpinner, 80);
+		timer.unref();
+		drawSpinner();
+	},
+	update(text) {
+		label = text;
+	},
+	/** Wipes the frame; the next tick draws it again under what was printed. */
+	clear() {
+		if (drawn) process.stderr.write("\r\x1B[2K");
+		drawn = false;
+	},
+	stop() {
+		clearInterval(timer);
+		timer = void 0;
+		spinner.clear();
+	}
+};
+/** A line with a secret in it loses its colors: escapes between its characters would let the secret through. */
+function write(stream, sink, text) {
+	const plain = stripVTControlCharacters(text);
+	const safe = redact(plain);
+	spinner.clear();
+	sink(hasColors(stream) && safe === plain ? text : safe);
+}
+var out = (text) => write(process.stdout, console.log, text);
+var err = (text) => write(process.stderr, console.error, text);
+/** `4.2ms`, `420ms`, `4.20s`, `42.0s`, `4m 02s`: the precision nuxi gives its timings. */
+function formatDuration(ms) {
+	if (ms < 10) return `${ms.toFixed(1)}ms`;
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	if (ms < 1e4) return `${(Math.floor(ms / 10) / 100).toFixed(2)}s`;
+	if (ms < 6e4) return `${(Math.floor(ms / 100) / 10).toFixed(1)}s`;
+	const total = Math.floor(ms / 1e3);
+	return `${Math.floor(total / 60)}m ${String(total % 60).padStart(2, "0")}s`;
+}
+/** The word for a count: `pick(1, 'was', 'were')`. */
+var pick = (count, one, many) => count === 1 ? one : many;
+/** A count and its noun, in agreement: `1 key`, `2 keys`. */
+var plural = (count, one, many = `${one}s`) => `${count} ${pick(count, one, many)}`;
+/** A table or a group was printed last: the line after it is a summary and stands apart. */
+var afterBlock = false;
+var heading = (title, count) => `\n${style("cyan", symbols.step)} ${style("bold", title)}${count === void 0 ? "" : style("gray", ` (${count})`)}`;
+var log = {
+	setSilent(value) {
+		silent = value;
+	},
+	/** A bare line, for text that is part of a block. */
+	info(message) {
+		if (!silent) out(message);
+	},
+	/** A line of its own: what the command is doing or found. */
+	note(message) {
+		if (!silent) out(`${log.gap()}${style("blue", symbols.info)} ${indentLines(message)}`);
+	},
+	success(message) {
+		if (!silent) out(`${log.gap()}${style("green", symbols.success)} ${indentLines(message)}`);
+	},
+	warn(message) {
+		err(`${log.gap()}${style("yellow", symbols.warn)} ${indentLines(message)}`);
+	},
+	/** A blank line when a group or a table came last, once. */
+	gap() {
+		const gap = afterBlock ? "\n" : "";
+		afterBlock = false;
+		return gap;
+	},
+	error(message) {
+		err(style("red", message));
+	},
+	/** Stderr as is: the error report builds its own lines. */
+	raw(message) {
+		err(message);
+	},
+	/** Machine-readable output: not muted by `--logLevel silent`. */
+	json(value) {
+		spinner.clear();
+		console.log(redact(JSON.stringify(value, null, 2)));
+	},
+	section(title) {
+		log.info(heading(title));
+	},
+	rows(rows) {
+		const width = Math.max(0, ...rows.map(([label]) => label.length));
+		const tint = (value) => value.includes("\x1B") ? value : style("cyan", value);
+		for (const [label, value] of rows) log.info(`  ${style("bold", `${label}:`.padEnd(width + 2))}${tint(String(value))}`);
+		afterBlock = !silent;
+	},
+	/** A titled group with its count; cells of a row are aligned as a table. */
+	list(title, items) {
+		if (items.length === 0) return;
+		log.info(heading(title, items.length));
+		const lines = items.every((item) => Array.isArray(item)) ? columns(items) : items.map((item) => [item].flat().join(" "));
+		for (const line of lines) log.info(`  ${line}`);
+		afterBlock = !silent;
+	}
+};
+var prompt;
+var lines;
+/**
+* One line of input. Closed stdin (CI, a pipe that ended) answers `null`, never hangs.
+*
+* A single reader for the whole run: readline buffers ahead, so a second one would miss
+* lines a pipe already delivered.
+*/
+async function ask(question) {
+	prompt ??= createInterface({
+		input: process.stdin,
+		terminal: false
+	});
+	lines ??= prompt[Symbol.asyncIterator]();
+	spinner.stop();
+	process.stdout.write(`${question} `);
+	const line = await lines.next();
+	return line.done ? null : String(line.value).trim();
+}
+function closePrompts() {
+	prompt?.close();
+	prompt = void 0;
+	lines = void 0;
+}
+async function choose(question, options) {
+	for (const [index, option] of options.entries()) log.info(`  ${index + 1}. ${option}`);
+	const answer = await ask(`${question} [1-${options.length}]`);
+	return options[Number(answer) - 1] ?? null;
+}
+// src/errors.ts
+/** An expected failure: printed as message, details and hints, never as a stack trace. */
+var CliError = class extends Error {
+	code;
+	hints;
+	details;
+	constructor(message, options) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "CliError";
+		this.code = options.code;
+		this.hints = options.hints ?? [];
+		this.details = options.details ?? {};
+	}
+};
+var factory = (code) => (message, hints = [], details) => new CliError(message, {
+	code,
+	hints,
+	details
+});
+var usageError = factory("USAGE_ERROR");
+var validationError = factory("VALIDATION_ERROR");
+var notFoundError = factory("NOT_FOUND");
+var commandFailed = factory("COMMAND_FAILED");
+var remoteConfigError = factory("REMOTE_CONFIG_ERROR");
+/** The command worked and found something wrong: exit code 1, not a failure of the tool. */
+var findingsError = factory("FINDINGS");
+function fromSystemError(error) {
+	if (error.code === "ENOENT") return new CliError(`Path not found: ${error.path ?? "unknown"}`, {
+		code: "FILE_NOT_FOUND",
+		cause: error
+	});
+	if (error.code === "EACCES" || error.code === "EPERM") return new CliError(`Permission denied: ${error.path ?? "unknown"}`, {
+		code: "PERMISSION_DENIED",
+		cause: error
+	});
+	return null;
+}
+function normalize(error) {
+	if (error instanceof CliError) return error;
+	const system = error instanceof Error ? fromSystemError(error) : null;
+	if (system) return system;
+	return new CliError(error instanceof Error ? error.message : String(error), {
+		code: "COMMAND_FAILED",
+		hints: ["Run with --debug for a stack trace."],
+		cause: error
+	});
+}
+/** nuxi's look: a red ` ERROR ` badge on a terminal, the clack error symbol in a log; hints after an arrow. */
+function reportError(error, debug) {
+	const normalized = normalize(error);
+	const findings = normalized.code === "FINDINGS";
+	const badge = isInteractive(process.stderr) ? style(findings ? ["bgYellow", "black"] : ["bgRed", "black"], findings ? " FAIL " : " ERROR ") : style(findings ? "yellow" : "red", symbols.error);
+	log.raw(`${log.gap()}${badge} ${normalized.message}`);
+	for (const [label, value] of Object.entries(normalized.details)) log.raw(`  ${style("gray", `${label}:`)} ${value}`);
+	for (const hint of normalized.hints) log.raw(`  ${style("cyan", symbols.arrow)} ${hint}`);
+	if (debug) log.raw(style("gray", String(normalized.cause?.stack ?? normalized.stack)));
+	process.exitCode = findings ? 1 : 2;
+}
+// src/json.ts
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A lookup by a name from outside: `constructor` is not an entry of a table. */
+var ownValue = (table, name) => Object.hasOwn(table, name) ? table[name] : void 0;
+var isEmptyObject = (value) => isObject(value) && Object.keys(value).length === 0;
+/**
+* `{ a: { b: 'x' } }` -> `{ 'a.b': 'x' }`. Arrays and empty objects are leaves. No prototype:
+* callers look keys up in the result, and `constructor` is a key like any other.
+*/
+function flatten(tree, prefix = "", out = Object.create(null)) {
+	for (const [key, value] of Object.entries(tree)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (isObject(value) && !isEmptyObject(value)) flatten(value, path, out);
+		else out[path] = value;
+	}
+	return out;
+}
+/** Only the string leaves: the part of a tree that is text to translate. */
+function flattenStrings(tree) {
+	const out = Object.create(null);
+	for (const [key, value] of Object.entries(flatten(tree))) if (typeof value === "string") out[key] = value;
+	return out;
+}
+/**
+* The object and key holding `path`. Dotted names are valid keys and the runtime reads them
+* first, so `{ "a.b": 1 }` and `{ a: { "b.c": 1 } }` resolve like nested ones.
+*/
+function locate(tree, path) {
+	if (Object.hasOwn(tree, path)) return [tree, path];
+	for (let index = path.indexOf("."); index !== -1; index = path.indexOf(".", index + 1)) {
+		const head = path.slice(0, index);
+		const child = Object.hasOwn(tree, head) ? tree[head] : void 0;
+		const found = isObject(child) ? locate(child, path.slice(index + 1)) : null;
+		if (found) return found;
+	}
+	return null;
+}
+function getPath(tree, path) {
+	const found = locate(tree, path);
+	return found ? found[0][found[1]] : void 0;
+}
+/** The leaf a new `path` would have to replace: `a` when `a` is text and `a.b` is wanted. */
+function blockingLeaf(tree, path) {
+	const parts = path.split(".");
+	for (let length = 1; length < parts.length; length += 1) {
+		const prefix = parts.slice(0, length).join(".");
+		const value = getPath(tree, prefix);
+		if (value !== void 0 && !isObject(value)) return prefix;
+	}
+	return null;
+}
+/**
+* What writing `path` would destroy: a text above it, or the keys below it. Every write that
+* comes from outside the file (import, pull, translation, generated key) asks this first.
+*/
+function pathConflict(tree, path) {
+	const current = getPath(tree, path);
+	if (current === void 0) return blockingLeaf(tree, path);
+	return isObject(current) && !isEmptyObject(current) ? path : null;
+}
+/** What can go between quotes in a template and a script, and be stored. */
+var isWritableKey = (key) => !/['"`\\\r\n]|\}\}|\$\{|&#?\w+;/.test(key) && key.split(".").every((segment) => segment !== "" && segment !== "__proto__");
+function setPath(tree, path, value) {
+	const found = locate(tree, path);
+	if (found) {
+		found[0][found[1]] = value;
+		return;
+	}
+	const parts = path.split(".");
+	const last = parts.pop();
+	if ([...parts, last].includes("__proto__")) return;
+	let current = tree;
+	for (const part of parts) {
+		if (!isObject(current[part])) current[part] = {};
+		current = current[part];
+	}
+	current[last] = value;
+}
+/** Remove one leaf and the parents it leaves empty. Everything else stays exactly as written. */
+function deletePath(tree, path) {
+	if (Object.hasOwn(tree, path)) return delete tree[path];
+	for (let index = path.indexOf("."); index !== -1; index = path.indexOf(".", index + 1)) {
+		const head = path.slice(0, index);
+		const child = Object.hasOwn(tree, head) ? tree[head] : void 0;
+		if (!isObject(child) || !deletePath(child, path.slice(index + 1))) continue;
+		if (isEmptyObject(child)) delete tree[head];
+		return true;
+	}
+	return false;
+}
+/** The string is unrolled: an alternation in a loop overflows the regexp stack on a value of megabytes. */
+var JSON_TOKEN = /"[^"\\]*(?:\\.[^"\\]*)*"|[{}[\]:]/g;
+/** The first key an object repeats. `JSON.parse` keeps the last and says nothing, and a save would lose the other. */
+function findDuplicateKey(text) {
+	const stack = [];
+	let lastString = "";
+	for (const [token] of text.matchAll(JSON_TOKEN)) if (token === "{") stack.push(/* @__PURE__ */ new Set());
+	else if (token === "[") stack.push(null);
+	else if (token === "}" || token === "]") stack.pop();
+	else if (token !== ":") lastString = token.includes("\\") ? JSON.parse(token) : token.slice(1, -1);
+	else if (stack.at(-1)?.has(lastString)) return lastString;
+	else stack.at(-1)?.add(lastString);
+	return null;
+}
+/** The merge and the writers skip this key, so it would vanish on a save. */
+function hasProtoKey(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return Object.hasOwn(value, "__proto__") || Object.values(value).some(hasProtoKey);
+}
+/** The path of an integer `JSON.parse` could not hold exactly. */
+function findUnsafeInteger(value, path = "") {
+	if (typeof value === "number") return Number.isInteger(value) && !Number.isSafeInteger(value) ? path : null;
+	if (typeof value !== "object" || value === null) return null;
+	for (const [key, child] of Object.entries(value)) {
+		const found = findUnsafeInteger(child, path ? `${path}.${key}` : key);
+		if (found !== null) return found;
+	}
+	return null;
+}
+/** `Map.groupBy`, which Node 20 does not have. */
+function groupBy(items, keyOf) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = keyOf(item);
+		if (groups.has(key)) groups.get(key).push(item);
+		else groups.set(key, [item]);
+	}
+	return groups;
+}
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (!isObject(value)) return value;
+	const sorted = {};
+	for (const key of Object.keys(value).sort((a, b) => a.localeCompare(b, "en"))) sorted[key] = sortKeys(value[key]);
+	return sorted;
+}
+export { log as A, addSecret as C, closePrompts as D, choose as E, urlParts as F, plural as M, spinner as N, formatDuration as O, style as P, validationError as S, ask as T, findingsError as _, flattenStrings as a, reportError as b, hasProtoKey as c, ownValue as d, pathConflict as f, commandFailed as g, CliError as h, flatten as i, pick as j, isInteractive as k, isObject as l, sortKeys as m, findDuplicateKey as n, getPath as o, setPath as p, findUnsafeInteger as r, groupBy as s, deletePath as t, isWritableKey as u, notFoundError as v, addUrlSecrets as w, usageError as x, remoteConfigError as y };