@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/load-gW-oJt1Q.js

@@ -0,0 +1,747 @@
+import { a as diagnosticError, i as ID_LENGTH, n as DEFAULT_CONFIG, r as DEFAULT_IMPORT_SOURCES, t as CONFIG_FILE } from "./types-D3QGM8XO.js";
+import { t as excludeKind } from "./exclude-Du-Zd_qI.js";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+//#region src/core/config/schema.ts
+/**
+* The zod 4 schema of `vi18n.config.ts` (PLAN §5.7, INTERNALS §2.7.1). It
+* checks shapes and per-field rules only; rules that relate two keys
+* (`sourceLocale` ∈ `locales`, fallbacks, pseudo-locales, `ai.exclude`) need
+* the defaults applied first and live in `crossFieldProblems`, so a config
+* that leaves `locales` out is judged against `[sourceLocale]`.
+*
+* Every key is optional: defaults are applied by `resolveConfig`, never by
+* zod, so the parsed value still tells which keys the user wrote.
+*/
+/**
+* `TIME_ZONE_COOKIE` of `src/server/types.ts`, which core may not import
+* (INTERNALS §0); the schema tests check the two agree.
+*/
+const TIME_ZONE_COOKIE = "vi18n_tz";
+/** Problem with a locale tag, or null when it is valid and canonical. */
+function localeProblem(tag) {
+	let canonical;
+	try {
+		canonical = Intl.getCanonicalLocales(tag)[0];
+	} catch {
+		return `${JSON.stringify(tag)} is not a valid BCP 47 locale tag`;
+	}
+	if (canonical !== tag) return `${JSON.stringify(tag)} is not canonical (write ${JSON.stringify(canonical)})`;
+	return null;
+}
+const IANA_ZONE = "an IANA time zone name such as \"Europe/Berlin\"";
+/**
+* Problem with `ssr.timeZone`, or null. The rule is `isTimeZone` of
+* `src/server/catalogs.ts`, which core may not import (the schema tests check
+* the two agree): a name starts with a letter, has at most 64 characters and
+* Intl accepts it. UTC offsets, which Intl accepts too, are refused there
+* (each spelling would get its own formatter in caches keyed by zone), so a
+* config naming one must fail here rather than in `registerCatalogs()`.
+*/
+function timeZoneProblem(zone) {
+	if (/^[+\-\d]/.test(zone) || zone.charCodeAt(0) === 8722) return `must be ${IANA_ZONE}, not a UTC offset`;
+	const problem = `must be ${IANA_ZONE} that Intl.DateTimeFormat accepts`;
+	if (zone.length > 64 || !/^[a-z]/i.test(zone)) return problem;
+	try {
+		new Intl.DateTimeFormat("en", { timeZone: zone });
+		return null;
+	} catch {
+		return problem;
+	}
+}
+function isProvider(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const provider = value;
+	return typeof provider.name === "string" && provider.name !== "" && typeof provider.model === "string" && typeof provider.translate === "function";
+}
+/** `defaults.tags` keys: the message tag names FormatJS parses, ASCII only. */
+const TAG_NAME = /^[A-Za-z][\w.-]*$/;
+const ATTRIBUTE_NAME = /^[A-Za-z][\w:.-]*$/;
+/**
+* Elements whose content HTML does not parse as text: escaped translator
+* text inside `<script>` or `<style>` would still run (INTERNALS §6 D205).
+*/
+const RAW_TEXT = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"iframe",
+	"noembed",
+	"noframes",
+	"noscript",
+	"plaintext",
+	"xmp"
+]);
+const element = z.string().regex(/^[a-z][a-z\d-]*$/, { error: "an HTML element name in lower case" }).refine((name) => !RAW_TEXT.has(name), { error: "must render its children as text (not script, style, iframe or noscript)" });
+/** PLAN §5.20: batches of 40–80 items. */
+const BATCH_SIZE_RANGE = "must be an integer from 40 to 80";
+const text = z.string().min(1, { error: "must be a non-empty string" });
+const locale = z.string().superRefine((value, ctx) => {
+	const problem = localeProblem(value);
+	if (problem !== null) ctx.addIssue({
+		code: "custom",
+		message: problem
+	});
+});
+const positiveInt = z.number({ error: "must be a positive integer" }).int({ error: "must be a positive integer" }).positive({ error: "must be a positive integer" });
+const withLocale = z.string().includes("{locale}", { error: "must contain {locale}" });
+const manifestPath = withLocale.refine((path) => path.indexOf("{locale}", path.indexOf("{locale}") + 1) < 0, { error: "must contain {locale} exactly once" });
+const routePattern = z.string().startsWith("/", { error: "route patterns start with /" });
+const strategy = z.enum([
+	"url",
+	"cookie",
+	"header",
+	"localStorage",
+	"default"
+]);
+const level = z.enum([
+	"off",
+	"warn",
+	"error"
+]);
+const outputSchema = z.strictObject({
+	split: z.strictObject({
+		shared: z.enum(["per-set", "single"]).optional(),
+		dupBelow: positiveInt.optional(),
+		minBytes: positiveInt.optional(),
+		maxBundlesPerRoot: positiveInt.nullable().optional()
+	}).optional(),
+	guard: z.enum([
+		"auto",
+		"always",
+		"off"
+	]).optional(),
+	manifestPath: manifestPath.optional(),
+	manifest: z.enum(["data", "module"]).optional(),
+	baseEntries: z.array(text).optional(),
+	compactIds: z.boolean().optional(),
+	perLocale: z.boolean().optional()
+});
+const configSchema = z.strictObject({
+	sourceLocale: locale.optional(),
+	locales: z.array(locale).min(1, { error: "must list at least one locale" }).optional(),
+	pseudoLocales: z.array(z.enum(["en-XA", "ar-XB"])).optional(),
+	fallbacks: z.record(locale, z.array(locale)).optional(),
+	project: z.strictObject({
+		include: z.array(text).optional(),
+		extensions: z.array(z.string().regex(/^\.[^./\\]+$/, { error: "must look like \".tsx\"" })).optional(),
+		exclude: z.array(text).optional()
+	}).optional(),
+	extraction: z.strictObject({
+		importSources: z.array(text).optional(),
+		aliases: z.array(text).optional(),
+		globals: z.array(text).optional(),
+		keep: z.array(text).optional(),
+		dependencies: z.array(z.string().regex(/^(?:@[a-z0-9][\w.~-]*\/)?[a-z0-9][\w.~-]*$/, { error: "must be a package name, like \"@acme/ui\"" })).refine((names) => new Set(names).size === names.length, { error: "lists a package twice" }).optional()
+	}).optional(),
+	ids: z.strictObject({ length: z.number({ error: `must be an integer from ${ID_LENGTH.min} to ${ID_LENGTH.max}` }).int({ error: `must be an integer from ${ID_LENGTH.min} to ${ID_LENGTH.max}` }).min(ID_LENGTH.min, { error: `must be an integer from ${ID_LENGTH.min} to ${ID_LENGTH.max}` }).max(ID_LENGTH.max, { error: `must be an integer from ${ID_LENGTH.min} to ${ID_LENGTH.max}` }).optional() }).optional(),
+	catalogs: z.strictObject({
+		format: z.enum(["po", "json"]).optional(),
+		path: withLocale.optional(),
+		msgid: z.enum(["source", "id"]).optional(),
+		icuFlag: z.boolean().optional()
+	}).refine((catalogs) => !(catalogs.icuFlag === true && catalogs.format === "json"), {
+		error: "is a PO flag; JSON catalogs have no #, line to carry it",
+		path: ["icuFlag"]
+	}).optional(),
+	output: outputSchema.optional(),
+	routing: z.strictObject({
+		strategy: z.array(strategy).optional(),
+		routeStrategies: z.record(routePattern, z.array(strategy)).optional(),
+		url: z.enum([
+			"prefix_except_default",
+			"prefix",
+			"prefix_and_default",
+			"no_prefix"
+		]).optional(),
+		redirectRoot: z.boolean().optional(),
+		propagate: z.union([z.literal("header"), z.literal(false)], { error: "must be \"header\" or false" }).optional(),
+		switch: z.enum(["in-place", "navigate"]).optional(),
+		cookie: z.strictObject({
+			name: z.string().regex(/^[!#$%&'*+\-.^`|~\w]+$/, { error: "must be a valid cookie name" }).refine((name) => name !== TIME_ZONE_COOKIE, { error: `${JSON.stringify(TIME_ZONE_COOKIE)} is reserved for the time-zone cookie` }).optional(),
+			maxAge: positiveInt.optional()
+		}).optional(),
+		base: z.string().regex(/^\/(?!\/)/, { error: "must be a path starting with \"/\"" }).nullable().optional(),
+		paths: z.record(z.string(), z.record(z.string(), z.string())).optional(),
+		domains: z.record(z.string(), z.string()).optional()
+	}).optional(),
+	ssr: z.strictObject({
+		timeZone: z.string().superRefine((value, ctx) => {
+			const problem = timeZoneProblem(value);
+			if (problem !== null) ctx.addIssue({
+				code: "custom",
+				message: problem
+			});
+		}).optional(),
+		timeZoneFrom: z.record(routePattern, z.enum(["config", "request"])).optional(),
+		payload: z.enum(["bundles", "preload"]).optional(),
+		catalogs: z.enum([
+			"auto",
+			"modules",
+			"assets"
+		]).optional(),
+		maxLoadedLocales: positiveInt.optional(),
+		normalizeSpaces: z.boolean().optional()
+	}).optional(),
+	ai: z.strictObject({
+		provider: z.custom((value) => value === "gemini" || isProvider(value), { error: "must be \"gemini\" or a provider object with name, model and translate()" }).optional(),
+		model: text.optional(),
+		exclude: z.array(z.string()).optional(),
+		glossary: z.record(text, z.record(z.string(), text)).optional(),
+		doNotTranslate: z.array(text).optional(),
+		tone: z.record(z.string(), z.string()).optional(),
+		description: z.string().optional(),
+		apiKeyEnv: z.string().regex(/^[A-Za-z_]\w*$/, { error: "must be an environment variable name" }).optional(),
+		batchSize: z.number({ error: BATCH_SIZE_RANGE }).int({ error: BATCH_SIZE_RANGE }).min(40, { error: BATCH_SIZE_RANGE }).max(80, { error: BATCH_SIZE_RANGE }).optional(),
+		concurrency: positiveInt.optional(),
+		dev: z.boolean().optional()
+	}).optional(),
+	defaults: z.strictObject({ tags: z.custom((tags) => typeof tags !== "object" || tags === null || !Object.hasOwn(tags, "__proto__"), { error: "\"__proto__\" is not a message tag name" }).pipe(z.record(z.string().regex(TAG_NAME, { error: "a message tag name (letters, digits, _ and -)" }), z.union([element, z.strictObject({
+		element,
+		attributes: z.record(z.string().regex(ATTRIBUTE_NAME, { error: "an HTML attribute name" }), z.string()).optional()
+	})]))).optional() }).optional(),
+	devtools: z.boolean().optional(),
+	strict: z.union([z.boolean(), z.strictObject({
+		missing: level.optional(),
+		invalid: level.optional(),
+		moduleScope: level.optional()
+	})], { error: "must be a boolean or { missing, invalid, moduleScope }" }).optional()
+});
+/** `a.b["pt-BR"][0]`: the key path as a user would write it. */
+function formatPath(path) {
+	let out = "";
+	for (const key of path) if (typeof key === "number") out += `[${key}]`;
+	else if (typeof key === "string" && /^[A-Za-z_$][\w$]*$/.test(key)) out += out === "" ? key : `.${key}`;
+	else out += `[${JSON.stringify(String(key))}]`;
+	return out;
+}
+/**
+* One `<key path>: <problem>` line per zod issue, nested union and key
+* issues flattened. `label` names the object the paths start from.
+*/
+function issueLines(issues, prefix = [], label = "") {
+	const lines = [];
+	const line = (path, message) => {
+		const key = formatPath(path);
+		const at = label === "" ? key || "config" : key === "" ? label : `${label}${key.startsWith("[") ? "" : "."}${key}`;
+		lines.push(`${at}: ${message}`);
+	};
+	for (const issue of issues) {
+		const path = [...prefix, ...issue.path];
+		switch (issue.code) {
+			case "unrecognized_keys":
+				for (const key of issue.keys) line([...path, key], "unknown key");
+				break;
+			case "invalid_key":
+				lines.push(...issueLines(issue.issues, path, label));
+				break;
+			case "invalid_union": {
+				const deep = issue.errors.filter((branch) => branch.some((inner) => inner.path.length > 0));
+				if (deep.length === 1) lines.push(...issueLines(deep[0], path, label));
+				else line(path, issue.message);
+				break;
+			}
+			default: line(path, issue.message.replace(/^Invalid (?:input|option): /, ""));
+		}
+	}
+	return lines;
+}
+//#endregion
+//#region src/core/config/routing.ts
+/** Segments of a validated path as a pathname spells them (`*` and `**` stay). */
+const segmentsOf = (path) => new URL(path, "http://h").pathname.split("/").slice(1);
+/**
+* What is wrong with a `routing.paths` key or value, or null. A route path
+* as routers spell it: from the root, no empty, `.` or `..` segment, no
+* query, fragment or backslash, no trailing slash; `*` stands for one whole
+* segment and a final `**` for any number, and one segment at least is fixed.
+*/
+function pathProblem(path) {
+	if (!path.startsWith("/")) return "must start with /";
+	if (path === "/") return "the root is not translated";
+	if (/[?#\\]/.test(path)) return "must be a path without ?, # or \\";
+	const segments = path.slice(1).split("/");
+	for (const [i, s] of segments.entries()) {
+		if (s === "") return "must not have empty segments or a trailing slash";
+		if (s === "." || s === "..") return "must not have . or .. segments";
+		if (s.includes("*") && s !== "*" && s !== "**") return "a wildcard is a whole segment: * or **";
+		if (s === "**" && i !== segments.length - 1) return "** must be the last segment";
+	}
+	if (segments.every((s) => s.startsWith("*"))) return "must have a segment that is not a wildcard";
+	return null;
+}
+/** The wildcard sequence of a path: what a translation must keep, in order. */
+const wildcards = (path) => path.split("/").filter((s) => s === "*" || s === "**").join("/");
+/** Whether some pathname matches both patterns. */
+function overlap(a, b) {
+	for (let i = 0;; i++) {
+		const x = a[i];
+		const y = b[i];
+		if (x === "**" || y === "**") return true;
+		if (x === void 0 || y === void 0) return x === y;
+		if (x !== y && x !== "*" && y !== "*") return false;
+	}
+}
+/** Host and port of a `routing.domains` key in origin form, or null when it is no plain origin. */
+function domainOrigin(key) {
+	const withScheme = key.includes("://") ? key : "https://" + key;
+	let url;
+	try {
+		url = new URL(withScheme);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+	if (url.username || url.password || url.search || url.hash || url.pathname !== "/") return null;
+	if (withScheme.replace(/^[a-z]+:\/\//i, "").includes("/")) return null;
+	return url.origin;
+}
+/** `routing.domains` with every key as `https://host[:port]` (or its `http:` origin). */
+function resolveDomains(domains) {
+	const out = {};
+	for (const [key, locale] of Object.entries(domains)) out[domainOrigin(key)] = locale;
+	return out;
+}
+/**
+* Rules between `routing.paths`, `routing.domains` and the other keys. Only
+* configured locales (never pseudo-locales, which are not advertised) may
+* have a path or a host.
+*/
+function routingProblems(routing, sourceLocale, locales) {
+	const problems = [];
+	const url = routing?.url ?? "prefix_except_default";
+	const paths = routing?.paths ?? {};
+	const domains = routing?.domains ?? {};
+	const hasDomains = Object.keys(domains).length > 0;
+	const at = (...keys) => formatPath(["routing", ...keys]);
+	if (hasDomains && url !== "prefix_except_default") problems.push(`${at("domains")}: needs routing.url "prefix_except_default" (a host's locale is its unprefixed one, every other host's prefix is redirected to that host)`);
+	const seen = /* @__PURE__ */ new Map();
+	for (const [key, locale] of Object.entries(domains)) {
+		const origin = domainOrigin(key);
+		if (origin === null) {
+			problems.push(`${at("domains", key)}: must be a host such as "example.de" or an origin such as "http://localhost:5173"`);
+			continue;
+		}
+		const other = seen.get(origin);
+		if (other !== void 0) problems.push(`${at("domains", key)}: the same host as "${other}"`);
+		seen.set(origin, key);
+		if (!locales.includes(locale)) problems.push(`${at("domains", key)}: ${JSON.stringify(locale)} is not in locales`);
+	}
+	if (hasDomains) {
+		const served = new Set(Object.values(domains));
+		for (const l of locales) if (!served.has(l)) problems.push(`${at("domains")}: no host serves ${JSON.stringify(l)} (every locale needs one)`);
+	}
+	const keys = Object.keys(paths);
+	if (keys.length > 0 && url === "no_prefix") problems.push(`${at("paths")}: needs URLs that name their locale (a routing.url other than "no_prefix")`);
+	const valid = [];
+	for (const key of keys) {
+		const problem = pathProblem(key);
+		if (problem !== null) {
+			problems.push(`${at("paths", key)}: ${problem}`);
+			continue;
+		}
+		let ok = true;
+		for (const [locale, value] of Object.entries(paths[key])) {
+			const where = at("paths", key, locale);
+			if (!locales.includes(locale)) {
+				problems.push(`${where}: ${JSON.stringify(locale)} is not in locales`);
+				ok = false;
+			}
+			const p = pathProblem(value);
+			if (p !== null) {
+				problems.push(`${where}: ${p}`);
+				ok = false;
+			} else if (wildcards(value) !== wildcards(key)) {
+				problems.push(`${where}: must keep the wildcards of ${JSON.stringify(key)}, in order`);
+				ok = false;
+			}
+		}
+		if (ok) valid.push(key);
+	}
+	const form = (key, l) => Object.hasOwn(paths[key], l) ? paths[key][l] : key;
+	const seg = new Map(valid.map((k) => [k, segmentsOf(k)]));
+	const segOf = (p) => seg.get(p) ?? segmentsOf(p);
+	const unprefixed = url === "prefix" || url === "no_prefix" ? [] : hasDomains ? locales : [sourceLocale];
+	for (const l of locales) {
+		for (let i = 0; i < valid.length; i++) {
+			const a = valid[i];
+			const fa = form(a, l);
+			for (let j = i + 1; j < valid.length; j++) {
+				const b = valid[j];
+				const fb = form(b, l);
+				const where = at("paths", Object.hasOwn(paths[b], l) ? b : a, l);
+				if (fa === fb) problems.push(`${where}: ${JSON.stringify(a)} and ${JSON.stringify(b)} share the path ${JSON.stringify(fa)} in ${l}`);
+				else if (overlap(segOf(fa), segOf(fb)) && !overlap(segOf(a), segOf(b))) problems.push(`${where}: ${JSON.stringify(fa)} and ${JSON.stringify(fb)} overlap in ${l}, but ${JSON.stringify(a)} and ${JSON.stringify(b)} do not`);
+			}
+		}
+		if (!unprefixed.includes(l)) continue;
+		for (const a of valid) for (const b of valid) {
+			if (a === b || !Object.hasOwn(paths[b], l)) continue;
+			if (overlap(segOf(a), segOf(paths[b][l]))) problems.push(`${at("paths", b, l)}: ${JSON.stringify(paths[b][l])} would read as the route ${JSON.stringify(a)} where ${l} is unprefixed`);
+		}
+	}
+	return problems;
+}
+//#endregion
+//#region src/core/config/load.ts
+/**
+* Finding, loading and resolving `vi18n.config.ts` (PLAN §5.7, INTERNALS
+* §2.7.1, spike S8). The plugin and the CLI both come through `loadConfig`,
+* so they can never disagree about a project's config.
+*/
+const JSON_CATALOG_PATH = "locales/{locale}.json";
+/**
+* Walks up from `from` to the workspace root (inclusive) and returns the
+* first `vi18n.config.ts`. Stopping at the workspace root keeps a project
+* from picking up a config that belongs to an unrelated checkout above it.
+*/
+async function findConfigFile(from) {
+	let dir = resolve(from);
+	for (;;) {
+		const candidate = join(dir, CONFIG_FILE);
+		if (await isFile(candidate)) return candidate;
+		if (await isWorkspaceRoot(dir)) return null;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+async function isWorkspaceRoot(dir) {
+	if (await exists(join(dir, ".git"))) return true;
+	if (await isFile(join(dir, "pnpm-workspace.yaml"))) return true;
+	let manifest;
+	try {
+		manifest = JSON.parse((await readFile(join(dir, "package.json"), "utf8")).replace(/^\uFEFF/, ""));
+	} catch {
+		return false;
+	}
+	return typeof manifest === "object" && manifest !== null && manifest.workspaces != null;
+}
+async function exists(file) {
+	try {
+		await stat(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isFile(file) {
+	try {
+		return (await stat(file)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function loadConfig(options) {
+	const cwd = resolve(options.cwd);
+	let file;
+	if (options.configFile != null) {
+		file = resolve(cwd, options.configFile);
+		if (!await isFile(file)) throw diagnosticError({
+			code: "config-not-found",
+			severity: "error",
+			message: `Config file ${file} not found`,
+			file: toPosix(file)
+		});
+		if (!/\.m?ts$/.test(file)) throw invalid(basename(file), `${basename(file)}: only a TypeScript module (vi18n.config.ts) is supported as a config`);
+	} else file = await findConfigFile(cwd);
+	const inline = options.output === void 0 ? void 0 : parseInlineOutput(options.output);
+	if (file === null) return resolveWith({}, cwd, null, inline);
+	return resolveWith(await importConfig(file), dirname(file), file, inline);
+}
+/**
+* Error codes of a native `import()` that a Vite transform can fix:
+* non-erasable TypeScript, extensionless or aliased specifiers, `.ts` inside
+* `node_modules`, JSON without an import attribute. Anything else was thrown
+* by the config's own code and would only be thrown again.
+*/
+const TRANSFORMABLE = /* @__PURE__ */ new Set([
+	"ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX",
+	"ERR_INVALID_TYPESCRIPT_SYNTAX",
+	"ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING",
+	"ERR_UNKNOWN_FILE_EXTENSION",
+	"ERR_MODULE_NOT_FOUND",
+	"ERR_UNSUPPORTED_DIR_IMPORT",
+	"ERR_PACKAGE_IMPORT_NOT_DEFINED",
+	"ERR_IMPORT_ATTRIBUTE_MISSING",
+	"ERR_IMPORT_ASSERTION_TYPE_MISSING"
+]);
+function needsTransform(error) {
+	if (!(error instanceof Error) || thrownByEvaluatedCode(error)) return false;
+	const code = error.code;
+	if (typeof code === "string") return TRANSFORMABLE.has(code);
+	return error.name === "SyntaxError";
+}
+/**
+* Parse, resolution and link errors are raised by Node's loader before any
+* module body runs, so all their synchronous frames are `node:` internals.
+* An error with a synchronous frame in a `file:` module was thrown while the
+* config or one of its imports ran: retrying would run their side effects a
+* second time and throw again (a runtime `JSON.parse` SyntaxError, say).
+* `at async` frames are skipped because they are callers such as this loader.
+*/
+function thrownByEvaluatedCode(error) {
+	return /^\s*at (?!async )(?:.*\()?file:\/\//m.test(error.stack ?? "");
+}
+/**
+* Configs this process has already imported natively. Node caches ESM by URL
+* for the life of the process and the `?t=` query busts only the config
+* itself, so a reload would see stale versions of the modules it imports;
+* the runner evaluates the whole graph afresh, so reloads go through it.
+*/
+const importedNatively = /* @__PURE__ */ new Set();
+async function importConfig(file) {
+	const rel = basename(file);
+	let module;
+	const vite = importedNatively.has(file) ? await loadVite() : null;
+	if (vite !== null) module = await runnerImport(vite, file, rel);
+	else {
+		importedNatively.add(file);
+		try {
+			const { mtimeMs } = await stat(file);
+			module = await import(pathToFileURL(file).href + "?t=" + Math.trunc(mtimeMs * 1e3));
+		} catch (nativeError) {
+			if (!needsTransform(nativeError)) throw loadError(rel, nativeError);
+			const fallback = await loadVite();
+			if (fallback === null) throw invalid(rel, `${rel} needs a transform Node cannot apply (${firstLine(nativeError)}); install vite or use erasable TypeScript only`);
+			module = await runnerImport(fallback, file, rel);
+		}
+	}
+	if (!("default" in module) || module.default === void 0) throw invalid(rel, `${rel} has no default export; export default defineConfig({ … })`);
+	try {
+		return await (typeof module.default === "function" ? module.default() : module.default);
+	} catch (error) {
+		throw loadError(rel, error);
+	}
+}
+async function loadVite() {
+	try {
+		return await import("vite");
+	} catch {
+		return null;
+	}
+}
+async function runnerImport(vite, file, rel) {
+	try {
+		const { module } = await vite.runnerImport(file, {
+			root: dirname(file),
+			logLevel: "silent"
+		});
+		return module;
+	} catch (error) {
+		throw loadError(rel, error);
+	}
+}
+function loadError(rel, cause) {
+	const error = invalid(rel, `${rel} could not be loaded: ${firstLine(cause)}`);
+	error.cause = cause;
+	return error;
+}
+function firstLine(error) {
+	return (error instanceof Error ? error.message : String(error)).split("\n", 1)[0].replace(/\.$/, "");
+}
+function invalid(file, message) {
+	return diagnosticError({
+		code: "config-invalid",
+		severity: "error",
+		message,
+		...file === void 0 ? {} : { file }
+	});
+}
+function parseInlineOutput(output) {
+	const result = outputSchema.safeParse(output);
+	if (result.success) return result.data;
+	throw invalid(void 0, issueLines(result.error.issues, [], "vi18n({ output })").join("; "));
+}
+/**
+* `inline` over the file's already validated `output`, `split` merged key by
+* key. Merging after validation means an inline value can never hide an
+* invalid one in the file, which the CLI (no inline options) would reject.
+*/
+function withOutput(file, inline) {
+	const merged = mergeDefined(file ?? {}, inline);
+	if (file?.split !== void 0 && inline.split !== void 0) merged.split = mergeDefined(file.split, inline.split);
+	return merged;
+}
+function mergeDefined(base, over) {
+	const out = { ...base };
+	for (const key of Object.keys(over)) if (over[key] !== void 0) out[key] = over[key];
+	return out;
+}
+/**
+* Validates `input` (the config's default export, already awaited) and
+* applies every default. Throws `config-invalid` naming each bad key path.
+*/
+function resolveConfig(input, root, configFile) {
+	return resolveWith(input, root, configFile, void 0);
+}
+function resolveWith(input, root, configFile, inline) {
+	root = resolve(root);
+	const file = configFile === null ? void 0 : toPosix(relativeOrAbsolute(root, configFile));
+	const result = configSchema.safeParse(input);
+	if (!result.success) throw invalid(file, issueLines(result.error.issues).join("; "));
+	const user = inline === void 0 ? result.data : {
+		...result.data,
+		output: withOutput(result.data.output, inline)
+	};
+	const sourceLocale = user.sourceLocale ?? DEFAULT_CONFIG.sourceLocale;
+	const locales = user.locales ? [...user.locales] : [sourceLocale];
+	const problems = crossFieldProblems(user, sourceLocale, locales);
+	if (problems.length > 0) throw invalid(file, problems.join("; "));
+	const d = DEFAULT_CONFIG;
+	const format = user.catalogs?.format ?? d.catalogs.format;
+	const catalogPath = user.catalogs?.path ?? (format === "json" ? JSON_CATALOG_PATH : d.catalogs.path);
+	const provider = user.ai?.provider ?? d.ai.provider;
+	return {
+		root,
+		configFile: configFile === null ? null : resolve(configFile),
+		sourceLocale,
+		locales,
+		pseudoLocales: [...new Set(user.pseudoLocales ?? d.pseudoLocales)],
+		fallbacks: copyRecord(user.fallbacks ?? d.fallbacks, (chain) => [...chain]),
+		project: {
+			include: (user.project?.include ?? d.project.include).map((entry) => resolve(root, entry)),
+			extensions: [...user.project?.extensions ?? d.project.extensions],
+			exclude: [...user.project?.exclude ?? d.project.exclude]
+		},
+		extraction: {
+			importSources: [.../* @__PURE__ */ new Set([...DEFAULT_IMPORT_SOURCES, ...user.extraction?.importSources ?? []])],
+			aliases: [...user.extraction?.aliases ?? d.extraction.aliases],
+			globals: [...user.extraction?.globals ?? d.extraction.globals],
+			keep: [...user.extraction?.keep ?? d.extraction.keep],
+			dependencies: [...user.extraction?.dependencies ?? d.extraction.dependencies]
+		},
+		ids: { length: user.ids?.length ?? d.ids.length },
+		catalogs: {
+			format,
+			path: resolve(root, catalogPath),
+			msgid: user.catalogs?.msgid ?? d.catalogs.msgid,
+			icuFlag: user.catalogs?.icuFlag ?? d.catalogs.icuFlag
+		},
+		output: resolveOutput(user.output),
+		routing: {
+			strategy: [...user.routing?.strategy ?? d.routing.strategy],
+			routeStrategies: copyRecord(user.routing?.routeStrategies ?? d.routing.routeStrategies, (chain) => [...chain]),
+			url: user.routing?.url ?? d.routing.url,
+			redirectRoot: user.routing?.redirectRoot ?? d.routing.redirectRoot,
+			propagate: user.routing?.propagate ?? d.routing.propagate,
+			switch: user.routing?.switch ?? d.routing.switch,
+			cookie: {
+				name: user.routing?.cookie?.name ?? d.routing.cookie.name,
+				maxAge: user.routing?.cookie?.maxAge ?? d.routing.cookie.maxAge
+			},
+			base: user.routing?.base ?? d.routing.base,
+			paths: copyRecord(user.routing?.paths ?? d.routing.paths, (entry) => ({ ...entry })),
+			domains: resolveDomains(user.routing?.domains ?? d.routing.domains)
+		},
+		ssr: {
+			timeZone: user.ssr?.timeZone ?? d.ssr.timeZone,
+			timeZoneFrom: copyRecord(user.ssr?.timeZoneFrom ?? d.ssr.timeZoneFrom, (v) => v),
+			payload: user.ssr?.payload ?? d.ssr.payload,
+			catalogs: user.ssr?.catalogs ?? d.ssr.catalogs,
+			maxLoadedLocales: user.ssr?.maxLoadedLocales ?? d.ssr.maxLoadedLocales,
+			normalizeSpaces: user.ssr?.normalizeSpaces ?? d.ssr.normalizeSpaces
+		},
+		ai: {
+			provider,
+			model: user.ai?.model ?? (typeof provider === "string" ? d.ai.model : provider.model),
+			exclude: [...user.ai?.exclude ?? d.ai.exclude],
+			glossary: copyRecord(user.ai?.glossary ?? d.ai.glossary, (targets) => copyRecord(targets, (v) => v)),
+			doNotTranslate: [...user.ai?.doNotTranslate ?? d.ai.doNotTranslate],
+			tone: copyRecord(user.ai?.tone ?? d.ai.tone, (v) => v),
+			description: user.ai?.description ?? d.ai.description,
+			apiKeyEnv: user.ai?.apiKeyEnv ?? d.ai.apiKeyEnv,
+			batchSize: user.ai?.batchSize ?? d.ai.batchSize,
+			concurrency: user.ai?.concurrency ?? d.ai.concurrency,
+			dev: user.ai?.dev ?? d.ai.dev
+		},
+		defaults: { tags: copyRecord(user.defaults?.tags ?? d.defaults.tags, (spec) => typeof spec === "string" ? spec : {
+			element: spec.element,
+			attributes: { ...spec.attributes }
+		}) },
+		devtools: user.devtools ?? d.devtools,
+		strict: resolveStrict(user.strict)
+	};
+}
+/** Rules between keys, checked once the locale list is known. */
+function crossFieldProblems(user, sourceLocale, locales) {
+	const problems = [];
+	const configured = /* @__PURE__ */ new Set();
+	locales.forEach((tag, index) => {
+		if (configured.has(tag)) problems.push(`locales[${index}]: ${JSON.stringify(tag)} is listed twice`);
+		configured.add(tag);
+	});
+	if (!configured.has(sourceLocale)) problems.push(`sourceLocale: ${JSON.stringify(sourceLocale)} is not in locales (add it to locales)`);
+	for (const [tag, chain] of Object.entries(user.fallbacks ?? {})) chain.forEach((target, index) => {
+		if (!configured.has(target)) problems.push(`${formatPath([
+			"fallbacks",
+			tag,
+			index
+		])}: ${JSON.stringify(target)} is not in locales`);
+	});
+	(user.pseudoLocales ?? []).forEach((tag, index) => {
+		if (configured.has(tag)) problems.push(`pseudoLocales[${index}]: ${JSON.stringify(tag)} is also in locales`);
+	});
+	const idLength = user.ids?.length ?? DEFAULT_CONFIG.ids.length;
+	(user.ai?.exclude ?? []).forEach((entry, index) => {
+		if (excludeKind(entry, locales, idLength) === null) problems.push(`ai.exclude[${index}]: ${JSON.stringify(entry)} is not a configured locale, a message id or a file glob (a glob contains / or *)`);
+	});
+	problems.push(...routingProblems(user.routing, sourceLocale, locales));
+	const languages = new Set(locales.map((tag) => tag.split("-")[0]));
+	for (const [term, targets] of Object.entries(user.ai?.glossary ?? {})) for (const tag of Object.keys(targets)) if (!configured.has(tag) && !languages.has(tag)) problems.push(`${formatPath([
+		"ai",
+		"glossary",
+		term,
+		tag
+	])}: ${JSON.stringify(tag)} is not in locales (nor the language of one)`);
+	return problems;
+}
+function resolveOutput(user) {
+	const d = DEFAULT_CONFIG.output;
+	return {
+		split: {
+			shared: user?.split?.shared ?? d.split.shared,
+			dupBelow: user?.split?.dupBelow ?? d.split.dupBelow,
+			minBytes: user?.split?.minBytes ?? d.split.minBytes,
+			maxBundlesPerRoot: user?.split?.maxBundlesPerRoot === void 0 ? d.split.maxBundlesPerRoot : user.split.maxBundlesPerRoot
+		},
+		guard: user?.guard ?? d.guard,
+		manifestPath: user?.manifestPath ?? d.manifestPath,
+		manifest: user?.manifest ?? d.manifest,
+		baseEntries: [...user?.baseEntries ?? d.baseEntries],
+		compactIds: user?.compactIds ?? d.compactIds,
+		perLocale: user?.perLocale ?? d.perLocale
+	};
+}
+function resolveStrict(strict) {
+	const d = DEFAULT_CONFIG.strict;
+	if (strict === true) return {
+		missing: "error",
+		invalid: "error",
+		moduleScope: "error"
+	};
+	if (strict === void 0 || strict === false) return { ...d };
+	const pick = (value, fallback) => value ?? fallback;
+	return {
+		missing: pick(strict.missing, d.missing),
+		invalid: pick(strict.invalid, d.invalid),
+		moduleScope: pick(strict.moduleScope, d.moduleScope)
+	};
+}
+/**
+* A fresh copy, so resolved configs never share arrays with the input or the
+* defaults. `fromEntries` defines properties, so a `__proto__` key stays a key.
+*/
+function copyRecord(record, copy) {
+	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, copy(value)]));
+}
+function relativeOrAbsolute(root, file) {
+	const rel = relative(root, resolve(file));
+	return rel === "" || rel.startsWith("..") || isAbsolute(rel) ? resolve(file) : rel;
+}
+function toPosix(path) {
+	return sep === "/" ? path : path.split(sep).join("/");
+}
+//#endregion
+export { loadConfig as n, resolveConfig as r, findConfigFile as t };