@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/import-nANvQutw.js

@@ -0,0 +1,225 @@
+import { m as updateCatalogFile } from "./library-D5CWvTQs.js";
+import { t as VERSION } from "./version-Byqi2guX.js";
+import { c as sourceIndexOf } from "./units-CQ5Q99RC.js";
+import { i as rootRelative, r as plural } from "./output-DWE3SIUA.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { a as loadCatalogs, o as loadProject, t as CliExit, u as readErrors } from "./project-C4GpaN-n.js";
+import { t as readImport } from "./formats-9unqj_fZ.js";
+import { t as applyImport } from "./apply-Bre-lY9J.js";
+import { basename, extname, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/cli/commands/import.ts
+/**
+* `vi18n import [--format f] [--locale l] [--dry-run] <file>…` (PLAN §4.4,
+* §5.19, INTERNALS §2.6.9): translations from exchange files into the
+* catalogs. A row is taken only for the exact source it was made for (D10),
+* and only into an entry the catalog already has, so an import never adds
+* messages or touches the source locale; everything left out is reported
+* with its reason. Writes go through the compare-and-swap writer, so a dev
+* server or another command writing meanwhile loses nothing.
+*/
+/** Skipped rows of these reasons are listed one by one; the rest are counted. */
+const LISTED = /* @__PURE__ */ new Set([
+	"source-changed",
+	"no-source",
+	"unsupported",
+	"duplicate"
+]);
+/** Per reason and file, so one stale export does not flood the terminal. */
+const LIST_LIMIT = 20;
+const WHY = {
+	unknown: "no entry has this key; run vi18n extract, or the message is gone",
+	"source-changed": "translated for other source text than the code has now",
+	"no-source": "nothing says which source text it was made for",
+	empty: "empty",
+	draft: "marked as needing work",
+	invalid: "not a valid translation of its source",
+	unsupported: "uses markup vi18n cannot read back",
+	duplicate: "a second row for the same key with another translation"
+};
+const UTF8 = new TextDecoder("utf-8", { fatal: true });
+async function importCatalogs(ctx, flags) {
+	const project = await loadProject(ctx);
+	const { config, codec, layout } = project;
+	const loaded = await loadCatalogs(project);
+	const unreadable = readErrors(loaded.diagnostics);
+	if (unreadable.length > 0) throw new CliExit(EXIT.failure, unreadable);
+	const context = {
+		layout,
+		codec,
+		sourceIndex: sourceIndexOf(loaded.set.get(config.sourceLocale)?.catalog ?? null, layout, codec)
+	};
+	const data = {
+		dryRun: flags.dryRun,
+		files: [],
+		changed: [],
+		skipped: []
+	};
+	let failed = false;
+	for (const name of flags.files) {
+		const path = resolve(ctx.global.cwd, name);
+		const shown = rootRelative(config.root, path);
+		const problem = (message, line = 0) => {
+			failed = true;
+			const diagnostic = {
+				code: "import-parse",
+				severity: "error",
+				message,
+				file: path
+			};
+			if (line > 0) diagnostic.line = line;
+			ctx.out.report([diagnostic]);
+		};
+		let text;
+		try {
+			text = UTF8.decode(await readFile(path));
+		} catch (error) {
+			const code = error.code;
+			problem(code === "ENOENT" ? "no such file" : error instanceof TypeError ? "the file is not valid UTF-8; export it as UTF-8" : `cannot read it: ${error instanceof Error ? error.message : String(error)}`);
+			continue;
+		}
+		const format = flags.format ?? inferFormat(path, text);
+		if (format === null) {
+			problem(`cannot tell the format from the extension ${JSON.stringify(extname(path))}; pass --format`);
+			continue;
+		}
+		const read = readImport(format, text, { msgid: config.catalogs.msgid });
+		if (read.error !== null) {
+			problem(`not a ${format} file vi18n can read: ${read.error.message}`, read.error.line);
+			continue;
+		}
+		if (read.srcLang != null && read.srcLang !== config.sourceLocale) {
+			problem(`its source language is ${read.srcLang}, but sourceLocale is ${config.sourceLocale}`);
+			continue;
+		}
+		const fromName = basename(path, extname(path));
+		const named = read.locale ?? (config.locales.includes(fromName) ? fromName : null);
+		if (flags.locale !== null && named !== null && read.locale !== null && flags.locale !== named) {
+			problem(`the file is for ${named}, not --locale ${flags.locale}`);
+			continue;
+		}
+		const locale = flags.locale ?? named;
+		if (locale === null) {
+			problem("the file does not name its locale; pass --locale");
+			continue;
+		}
+		if (locale === config.sourceLocale) {
+			problem(`${locale} is the source locale, which is compiled from code and takes no translations`);
+			continue;
+		}
+		if (!config.locales.includes(locale)) {
+			problem(`${locale} is not in locales (${config.locales.join(", ")})`);
+			continue;
+		}
+		const target = loaded.set.get(locale);
+		const apply = (catalog) => applyImport({
+			catalog,
+			records: read.records,
+			context,
+			locale
+		});
+		let outcome = null;
+		if (target === void 0 || target.catalog === null) {
+			problem(`${locale} has no catalog yet; run vi18n extract first`);
+			continue;
+		}
+		if (flags.dryRun) outcome = apply(target.catalog);
+		else await updateCatalogFile(target.path, target.hash, (current) => {
+			if (current === null) return null;
+			outcome = apply(current);
+			return outcome.catalog === current ? null : outcome.catalog;
+		}, {
+			locale,
+			layout,
+			isSourceLocale: false,
+			version: VERSION
+		});
+		if (outcome === null) {
+			problem(`${locale}'s catalog disappeared while importing; run vi18n extract`);
+			continue;
+		}
+		report(ctx, data, {
+			file: shown,
+			format,
+			locale,
+			outcome,
+			path
+		});
+	}
+	return {
+		exitCode: failed ? EXIT.failure : EXIT.ok,
+		data
+	};
+}
+function report(ctx, data, input) {
+	const { file, format, locale, outcome, path } = input;
+	const counts = {};
+	const listed = {};
+	const warnings = [];
+	for (const row of outcome.skipped) {
+		counts[row.reason] = (counts[row.reason] ?? 0) + 1;
+		data.skipped.push({
+			file,
+			locale,
+			line: row.line,
+			ref: row.ref,
+			id: row.id,
+			reason: row.reason
+		});
+		if (!LISTED.has(row.reason)) continue;
+		if ((listed[row.reason] = (listed[row.reason] ?? 0) + 1) > LIST_LIMIT) continue;
+		const diagnostic = {
+			code: "import-skipped",
+			severity: "warning",
+			message: `${row.ref}: ${WHY[row.reason]}; not imported`,
+			file: path,
+			locale
+		};
+		if (row.line > 0) diagnostic.line = row.line;
+		if (row.id !== null) diagnostic.id = row.id;
+		warnings.push(diagnostic);
+	}
+	ctx.out.report(warnings);
+	ctx.out.report(outcome.diagnostics.map((diagnostic) => ({
+		...diagnostic,
+		file: path
+	})));
+	for (const change of outcome.changed) data.changed.push({
+		file,
+		locale,
+		...change
+	});
+	data.files.push({
+		file,
+		format,
+		locale,
+		changed: outcome.changed.length,
+		unchanged: outcome.unchanged,
+		skipped: counts
+	});
+	const parts = Object.entries(counts).map(([reason, count]) => `${count} ${reason}`);
+	ctx.out.result(`${file} → ${locale}: ${outcome.changed.length} ${data.dryRun ? "to change" : "changed"}, ${outcome.unchanged} unchanged` + (parts.length === 0 ? "" : `, ${plural(outcome.skipped.length, "skipped row")} (${parts.join(", ")})`));
+}
+/**
+* The format from the extension. `.json` is vi18n's catalog format when the
+* file has a `messages` object (a flat file's values are all strings), else
+* flat JSON.
+*/
+function inferFormat(path, text) {
+	switch (extname(path).toLowerCase()) {
+		case ".po": return "po";
+		case ".xlf":
+		case ".xliff": return "xliff2";
+		case ".arb": return "arb";
+		case ".csv": return "csv";
+		case ".json": try {
+			const messages = JSON.parse(text.charCodeAt(0) === 65279 ? text.slice(1) : text)?.messages;
+			return typeof messages === "object" && messages !== null ? "json" : "flat";
+		} catch {
+			return "flat";
+		}
+		default: return null;
+	}
+}
+//#endregion
+export { importCatalogs };

package/dist/index.d.ts

@@ -0,0 +1,156 @@
+import { C as Locale, D as ValuesOf, E as RichValuesOf, S as LibraryMessages, T as RichPartsValuesOf, _ as TagHandler, a as Message, b as Values, c as MissingHandler, d as RichHtmlFunction, f as RichPart, g as TFunction, i as HtmlTagHandler, l as MissingInfo, n as Descriptor, o as MessageKey, p as RichPartsFunction, r as Fmt, s as MessageRef, t as DateInput, u as RichFunction, v as TemporalInput, w as Register, x as DefaultTags, y as Translator } from "./types-DsdWBG0b.js";
+//#region src/runtime/t.d.ts
+export declare const t: TFunction;
+/**
+ * Declares a message without rendering it; the build turns the call into its
+ * id. `msg({ id })` alone names a message an opted-in package declares, typed
+ * from its text (`vi18n.gen.ts`).
+ */
+export declare function msg<const M extends string>(message: M): MessageRef<ValuesOf<M>>;
+export declare function msg<const D extends Descriptor>(descriptor: D): MessageRef<ValuesOf<D["message"]>>;
+export declare function msg<const K extends Extract<keyof LibraryMessages, string>>(descriptor: {
+  readonly id: K;
+}): MessageRef<ValuesOf<LibraryMessages[K]>>;
+//#endregion
+//#region src/runtime/rich.d.ts
+/**
+ * Tag handlers come from `values` and receive `(children, key)`; React and
+ * Preact glue keys their results, and nodes passed as values, through
+ * `State.richKey`. A tag without a handler renders its children.
+ */
+export declare const rich: RichFunction;
+export declare const richHtml: RichHtmlFunction;
+export declare const richParts: RichPartsFunction;
+//#endregion
+//#region src/runtime/macro.d.ts
+/**
+ * The JSX `<T>` macro's runtime face (PLAN §4.1, INTERNALS §6 D215): the
+ * plugin's `vi18n:macro` pass replaces every `<T>…</T>` with a `rich()` call
+ * before React, Preact or Solid compile the JSX, so this function exists only
+ * to give the import a type and a value. Rendering it means no pass ran.
+ */
+/** What `<T>` takes: its children are the message; the rest feed extraction. */
+interface TProps {
+  children?: unknown;
+  /** Values for the arguments of an ICU string child, `{"{n, plural, …}"}`. */
+  values?: {
+    readonly [name: string]: unknown;
+  };
+  /** A manual id, as in `rich({ id, message })`. */
+  id?: string;
+  /** Context for translators. */
+  context?: string;
+  /** Length limit for translations. */
+  maxLength?: number;
+}
+export declare function T(props: TProps): never;
+declare namespace fmt_d_exports {
+  export { collator, compact, compare, currency, currencyMinor, date, dateRange, displayName, duration, list, number, percent, relative, segment, time, unit };
+}
+declare const number: Fmt["number"];
+declare const currency: Fmt["currency"];
+declare const currencyMinor: Fmt["currencyMinor"];
+declare const unit: Fmt["unit"];
+declare const compact: Fmt["compact"];
+declare const percent: Fmt["percent"];
+declare const date: Fmt["date"];
+declare const time: Fmt["time"];
+declare const dateRange: Fmt["dateRange"];
+declare const relative: Fmt["relative"];
+declare const list: Fmt["list"];
+declare const displayName: Fmt["displayName"];
+declare const duration: Fmt["duration"];
+declare const compare: Fmt["compare"];
+declare const collator: Fmt["collator"];
+declare const segment: Fmt["segment"];
+//#endregion
+//#region src/runtime/name.d.ts
+/**
+ * `localeName(locale)` (PLAN §4.1, §4.16): what a locale picker shows for a
+ * locale, its language's own name, and the `lang` of the text it shows, so
+ * screen readers read "Deutsch" in German inside an English page. It reads
+ * no state: an own-language name never depends on the current locale (the
+ * name in the current locale is `fmt.displayName`).
+ */
+/** `localeName()`'s result. */
+interface LocaleName {
+  /** The language's own name, first letter upper-cased as menus show it: "Deutsch", "Français". */
+  name: string;
+  /**
+   * The language `name` is in, for the element's `lang`: `locale` itself, the
+   * engine's default locale when it has no data for that language (the name
+   * is then in that language), or `""` (unknown) when the name is the code.
+   */
+  lang: string;
+}
+type LocaleNameOptions = Pick<Intl.DisplayNamesOptions, "style" | "languageDisplay">;
+export declare function localeName(locale: string, options?: LocaleNameOptions): LocaleName;
+//#endregion
+//#region src/runtime/zod.d.ts
+/**
+ * `vi18nZod()` (PLAN §4.1, INTERNALS §6 D206): a zod 4 `customError` that
+ * words issues through vi18n messages in the current locale, so
+ * `z.config({ customError: vi18nZod() })` localises every schema without a
+ * message of its own. It imports nothing from zod: the issue is typed
+ * structurally and zod only ever calls the function.
+ *
+ * The texts are not here. The extractor treats a `vi18nZod()` call as the
+ * `msg()` of each text in `src/core/extract/zod.ts` (catalog references
+ * point at the call) and the transform passes them in that order, as ids in
+ * builds and descriptors in dev, so they ship in the bundle of the module
+ * that calls it. Called unprocessed, it has none and zod keeps its own.
+ */
+/** The issue fields the bridge reads (zod 4's `$ZodRawIssue`, structurally). */
+interface ZodIssueLike {
+  readonly code?: string;
+  readonly input?: unknown;
+  readonly expected?: string;
+  readonly origin?: string;
+  readonly format?: string;
+  readonly minimum?: number | bigint;
+  readonly maximum?: number | bigint;
+  readonly inclusive?: boolean;
+  readonly exact?: boolean;
+  readonly keys?: readonly string[];
+}
+/** What `vi18nZod()` returns: zod 4's error-map shape. */
+type ZodErrorMap = (issue: ZodIssueLike) => string | undefined;
+export declare const vi18nZod: () => ZodErrorMap;
+//#endregion
+//#region src/runtime/locale.d.ts
+/** The active scope's locale: the request's on the server, the page's in the browser. */
+export declare const getLocale: () => Locale;
+/** Switches the page in place (or by document navigation, §2.11.7). Client only. */
+export declare const setLocale: (locale: Locale) => Promise<void>;
+/** Called with the new locale after every switch; returns an unsubscribe. */
+export declare const subscribe: (listener: (locale: Locale) => void) => (() => void);
+/** The app router's navigate function, for URL strategies (`setNavigator((href) => router.navigate(…))`). */
+export declare const setNavigator: (navigate: ((href: string) => unknown) | null) => void;
+/** Configured (and active pseudo-) locales, filled at registration; the same array forever. */
+export declare const locales: readonly Locale[];
+/** `"rtl"` or `"ltr"`; defaults to the current locale. */
+export declare const dir: (locale?: string) => "ltr" | "rtl";
+/** Settles once the page locale's boot and pending loads have settled. */
+export declare const ready: () => Promise<void>;
+/**
+ * For router intent hooks: loads the route's message bundles. The build fills
+ * `keys` from the `import()` inside `load`, which is never called: routers own
+ * code prefetching (§6 D45).
+ */
+export declare const preload: (_load: () => Promise<unknown>, keys?: readonly string[]) => Promise<void>;
+/** Missing-message reports, once per (key, locale); returns an unsubscribe. */
+export declare const onMissing: (handler: MissingHandler) => (() => void);
+/** A copy of `url` with its path in `locale` (default: the current one). */
+export declare const localizeUrl: (url: URL | string, locale?: Locale) => URL;
+/** A copy of `url` without its locale segment (router `rewrite`/`reroute` input). */
+export declare const delocalizeUrl: (url: URL | string) => URL;
+/**
+ * `href` in `locale` (default: the current one). Path-absolute and
+ * same-origin absolute hrefs are localized (with domains, hrefs on a listed
+ * host too, and a locale served by another listed host gives an absolute
+ * URL there); relative (`./x`, `x`, `?q`, `#h`) and cross-origin ones are
+ * returned unchanged.
+ */
+export declare function localizeHref(href: string, locale?: Locale): string;
+//#endregion
+export { type DateInput, type DefaultTags, type Descriptor, type Fmt, type HtmlTagHandler, type Locale, type LocaleName, type LocaleNameOptions, type Message, type MessageKey, type MessageRef, type MissingHandler, type MissingInfo, type Register, type RichPart, type RichPartsValuesOf, type RichValuesOf, type TFunction, type TProps, type TagHandler, type TemporalInput, type Translator, type Values, type ValuesOf, type ZodErrorMap, type ZodIssueLike, fmt_d_exports as fmt };

package/dist/index.js

@@ -0,0 +1,239 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { b as trim, d as resolved, n as S, t as textDirection } from "./dir-zw6bGMKQ.js";
+import { a as hostLocale, d as splitLocalePath, i as awayHref, n as atHome, r as atHost, s as localizePath, t as ROUTES } from "./url-CsBkRaJy.js";
+import { C as fTime, S as fSegment, _ as fDuration, b as fPercent, d as fCompare, f as fCurrency, g as fDisplayName, h as fDateRange, l as fCollator, m as fDate, n as msg, p as fCurrencyMinor, r as t, u as fCompact, v as fList, w as fUnit, x as fRelative, y as fNumber } from "./t-DC-c9zE5.js";
+import { i as richParts, n as richHtml, t as rich } from "./rich-DCUKl5HM.js";
+//#region src/runtime/macro.ts
+function T(props) {
+	throw new Error("vi18n: <T> is a compile-time macro and was not compiled: add vi18n() to the plugins of this Vite or Vitest config");
+}
+//#endregion
+//#region src/runtime/fmt.ts
+/**
+* The `fmt` namespace (PLAN §5.17): exactly the members of `Fmt`, each in the
+* active scope's locale, zone and `now`. Separate exports, so unused members
+* tree-shake out of `fmt.*` imports.
+*/
+var fmt_exports = /* @__PURE__ */ __exportAll({
+	collator: () => collator,
+	compact: () => compact,
+	compare: () => compare,
+	currency: () => currency,
+	currencyMinor: () => currencyMinor,
+	date: () => date,
+	dateRange: () => dateRange,
+	displayName: () => displayName,
+	duration: () => duration,
+	list: () => list,
+	number: () => number,
+	percent: () => percent,
+	relative: () => relative,
+	segment: () => segment,
+	time: () => time,
+	unit: () => unit
+});
+const scope = () => {
+	const s = S.resolve();
+	S.track();
+	return s;
+};
+const number = (v, o) => fNumber(scope(), v, o);
+const currency = (v, c, o) => fCurrency(scope(), v, c, o);
+const currencyMinor = (v, c, o) => fCurrencyMinor(scope(), v, c, o);
+const unit = (v, u, o) => fUnit(scope(), v, u, o);
+const compact = (v, o) => fCompact(scope(), v, o);
+const percent = (v, o) => fPercent(scope(), v, o);
+const date = (v, o) => fDate(scope(), v, o);
+const time = (v, o) => fTime(scope(), v, o);
+const dateRange = (a, b, o) => fDateRange(scope(), a, b, o);
+const relative = (v, o) => fRelative(scope(), v, o);
+const list = (items, o) => fList(scope(), items, o);
+const displayName = (code, o) => fDisplayName(scope(), code, o);
+const duration = (d, o) => fDuration(scope(), d, o);
+const compare = (a, b, o) => fCompare(scope(), a, b, o);
+const collator = (o) => fCollator(scope(), o);
+const segment = (text, o) => fSegment(scope(), text, o);
+//#endregion
+//#region src/runtime/name.ts
+/**
+* `localeName(locale)` (PLAN §4.1, §4.16): what a locale picker shows for a
+* locale, its language's own name, and the `lang` of the text it shows, so
+* screen readers read "Deutsch" in German inside an English page. It reads
+* no state: an own-language name never depends on the current locale (the
+* name in the current locale is `fmt.displayName`).
+*/
+const names = /* @__PURE__ */ new Map();
+function localeName(locale, options) {
+	const key = locale + JSON.stringify(options);
+	let n = names.get(key);
+	if (!n) {
+		try {
+			const d = new Intl.DisplayNames(locale, {
+				...options,
+				type: "language",
+				fallback: "none"
+			});
+			const lang = d.resolvedOptions().locale;
+			const name = d.of(locale);
+			n = {
+				name: name[0].toLocaleUpperCase(lang) + name.slice(1),
+				lang
+			};
+		} catch {
+			n = {
+				name: locale,
+				lang: ""
+			};
+		}
+		trim(names, 99);
+		names.set(key, n);
+	}
+	return n;
+}
+//#endregion
+//#region src/runtime/zod.ts
+/**
+* `vi18nZod()` (PLAN §4.1, INTERNALS §6 D206): a zod 4 `customError` that
+* words issues through vi18n messages in the current locale, so
+* `z.config({ customError: vi18nZod() })` localises every schema without a
+* message of its own. It imports nothing from zod: the issue is typed
+* structurally and zod only ever calls the function.
+*
+* The texts are not here. The extractor treats a `vi18nZod()` call as the
+* `msg()` of each text in `src/core/extract/zod.ts` (catalog references
+* point at the call) and the transform passes them in that order, as ids in
+* builds and descriptors in dev, so they ship in the bundle of the module
+* that calls it. Called unprocessed, it has none and zod keeps its own.
+*/
+const SIZES = {
+	string: 2,
+	array: 5,
+	set: 5,
+	map: 5,
+	file: 8
+};
+const FORMATS = [
+	"email",
+	"url",
+	"starts_with",
+	"ends_with",
+	"includes"
+];
+const vi18nZod = ((...m) => (issue) => {
+	if (!m.length) return;
+	const { code, origin = "", inclusive } = issue;
+	let i = 28;
+	let values = issue;
+	if (code === "invalid_type") i = issue.input == null ? 0 : 1;
+	else if (code === "too_small" || code === "too_big") {
+		const big = +(code === "too_big");
+		const n = big ? issue.maximum : issue.minimum;
+		const size = SIZES[origin];
+		if (size) {
+			i = size + (issue.exact ? 2 : big);
+			values = { count: inclusive === false ? Number(n) + 1 - 2 * big : n };
+		} else i = (origin === "date" ? 15 : 11) + 2 * big + +(inclusive === false);
+	} else if (code === "not_multiple_of") i = 19;
+	else if (code === "invalid_format") {
+		const f = FORMATS.indexOf(issue.format);
+		i = f < 0 ? 25 : 20 + f;
+	} else if (code === "invalid_value") i = 26;
+	else if (code === "unrecognized_keys") {
+		i = 27;
+		values = {
+			count: issue.keys.length,
+			keys: issue.keys.join(", ")
+		};
+	}
+	return t(m[i], values) || void 0;
+});
+//#endregion
+//#region src/runtime/locale.ts
+/**
+* The public locale API (PLAN §5.12, §5.14, §5.15). Every function goes
+* through the global state, so a duplicate runtime copy acts on the same page.
+*/
+/** The active scope's locale: the request's on the server, the page's in the browser. */
+const getLocale = () => S.resolve().locale;
+/** Switches the page in place (or by document navigation, §2.11.7). Client only. */
+const setLocale = (locale) => S.setLocale(locale);
+/** Called with the new locale after every switch; returns an unsubscribe. */
+const subscribe = (listener) => S.subscribe(listener);
+/** The app router's navigate function, for URL strategies (`setNavigator((href) => router.navigate(…))`). */
+const setNavigator = (navigate) => S.setNavigator(navigate);
+const localesOf = (s) => s.locales;
+/** Configured (and active pseudo-) locales, filled at registration; the same array forever. */
+const locales = /* #__PURE__ */ localesOf(S);
+/** `"rtl"` or `"ltr"`; defaults to the current locale. */
+const dir = (locale) => textDirection(locale ?? getLocale());
+/** Settles once the page locale's boot and pending loads have settled. */
+const ready = () => S.ready();
+/**
+* For router intent hooks: loads the route's message bundles. The build fills
+* `keys` from the `import()` inside `load`, which is never called: routers own
+* code prefetching (§6 D45).
+*/
+const preload = (_load, keys) => Array.isArray(keys) ? S.need(keys) : resolved;
+/** Missing-message reports, once per (key, locale); returns an unsubscribe. */
+const onMissing = (handler) => S.onMissing(handler);
+const origin = () => globalThis.location?.origin;
+/**
+* A copy of `url` (resolved against the page) with its pathname edited, once
+* registered; with domains, as the codec reads it on the URL's host.
+*/
+function edit(url, f) {
+	const u = new URL(url, origin());
+	const config = S.registration?.config;
+	if (config) u.pathname = f(u.pathname, ROUTES ? atHost(config, u.host) : config);
+	return u;
+}
+/**
+* `localizeUrl` where localized paths or domains may be configured: a locale
+* served by another listed host moves the URL there (INTERNALS §6 D135).
+*/
+function routedUrl(url, l) {
+	let away = null;
+	const u = edit(url, (p, c) => (away = awayHref(splitLocalePath(p, c).path, l, c)) ?? localizePath(p, l, c));
+	if (away === null) return u;
+	const to = new URL(away);
+	to.search = u.search;
+	to.hash = u.hash;
+	return to;
+}
+/** A copy of `url` with its path in `locale` (default: the current one). */
+const localizeUrl = (url, locale) => ROUTES ? routedUrl(url, locale ?? getLocale()) : edit(url, (p, c) => localizePath(p, locale ?? getLocale(), c));
+/**
+* A path-absolute href's path in `l` from the current page (whose host's
+* locale the client config carries) or request (`Scope.home`, servers):
+* absolute when `l` lives on another listed host.
+*/
+function routedPath(path, l, config) {
+	const c = atHome(config, S.serverResolver?.()?.home ?? config.routing.home);
+	return awayHref(splitLocalePath(path, c).path, l, c) ?? localizePath(path, l, c);
+}
+/** A copy of `url` without its locale segment (router `rewrite`/`reroute` input). */
+const delocalizeUrl = (url) => edit(url, (p, c) => splitLocalePath(p, c).path);
+/**
+* `href` in `locale` (default: the current one). Path-absolute and
+* same-origin absolute hrefs are localized (with domains, hrefs on a listed
+* host too, and a locale served by another listed host gives an absolute
+* URL there); relative (`./x`, `x`, `?q`, `#h`) and cross-origin ones are
+* returned unchanged.
+*/
+function localizeHref(href, locale) {
+	const config = S.registration?.config;
+	if (!config) return href;
+	if (href[0] === "/" && href[1] !== "/") {
+		const i = href.search(/[?#]/) >>> 0;
+		if (ROUTES) return routedPath(href.slice(0, i), locale ?? getLocale(), config) + href.slice(i);
+		return localizePath(href.slice(0, i), locale ?? getLocale(), config) + href.slice(i);
+	}
+	const base = globalThis.location?.href;
+	if (base && /^[\x00-\x20]*(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(href)) try {
+		const u = new URL(href, base);
+		if (u.origin === origin() || ROUTES && hostLocale(u.host, config) !== void 0) return localizeUrl(u, locale).href;
+	} catch {}
+	return href;
+}
+//#endregion
+export { T, delocalizeUrl, dir, fmt_exports as fmt, getLocale, localeName, locales, localizeHref, localizeUrl, msg, onMissing, preload, ready, rich, richHtml, richParts, setLocale, setNavigator, subscribe, t, vi18nZod };