@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/t-DC-c9zE5.js

@@ -0,0 +1,454 @@
+import { _ as DEV, b as trim, g as BUILD, l as quiet, n as S, t as textDirection, x as warnOnce, y as own } from "./dir-zw6bGMKQ.js";
+//#region src/runtime/bidi.ts
+/**
+* Automatic bidi isolation of interpolated strings (INTERNALS §2.3, PLAN
+* §4.2): a user-supplied name in Arabic inside an English sentence, or a Latin
+* name in Hebrew UI, must not reorder the text around it.
+*/
+const RTL_OR_CONTROL = /[\u0590-\u08FF\u200E\u200F\u202A-\u202E\u2066-\u2069\uFB1D-\uFDFF\uFE70-\uFEFE\u{10D00}-\u{10D3F}\u{1E900}-\u{1E95F}]/u;
+/**
+* Wraps `value` in FSI … PDI when the locale is RTL or the value carries RTL
+* text or bidi controls. Isolates inside the value are balanced first (UAX #9
+* X6a): a PDI without its initiator would close our FSI early and leave the
+* rest of the sentence to an override in the value, and an initiator without
+* its PDI would take our PDI and the rest of the sentence with it. `open`
+* counts the value's open isolates (a parameter, not a local: no block body).
+*/
+const isolate = (value, locale, open = 0) => value && (textDirection(locale) === "rtl" || RTL_OR_CONTROL.test(value)) ? "⁨" + value.replace(/[\u2066-\u2069]/g, (c) => (c < "⁩" ? ++open : open && open--) ? c : "") + "⁩".repeat(open + 1) : value;
+//#endregion
+//#region src/runtime/intl.ts
+/**
+* Intl formatter caches and the scope-taking implementations behind `fmt`
+* (PLAN §5.12, §5.17). Constructing an Intl formatter costs 23–228 µs and a
+* cached lookup under 1.5 µs (report 06), so no call path constructs one per
+* call: IR options are stable objects and get an identity-keyed cache, while
+* caller-supplied `fmt` options go through a bounded map keyed by value.
+*/
+/** Whether date options render a time of day. */
+const hasTime = (options) => [
+	"hour",
+	"minute",
+	"second",
+	"timeStyle",
+	"dayPeriod"
+].some((k) => own(options, k));
+/**
+* Maps U+202F to a plain space when `ssr.normalizeSpaces` is on, so server and
+* browser ICU versions hydrate to the same text. Numbers never come here: the
+* narrow no-break space is a real group separator there (`1 234,56`).
+*/
+const normalize = (text) => S.registration?.config.ssr.normalizeSpaces === false ? text : text.replace(/\u202F/g, " ");
+/** Time-of-day output: also marks the scope, so `/server` keeps per-user-zone responses private. */
+const timeText = (text, scope) => {
+	scope.formattedTime = true;
+	return normalize(text);
+};
+const NO_OPTIONS = [
+	{},
+	{},
+	{
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric"
+	}
+];
+const irCache = /* @__PURE__ */ new WeakMap();
+const interned = /* @__PURE__ */ new Map();
+const intern = (o) => {
+	const k = JSON.stringify(o);
+	let i = interned.get(k);
+	if (!i) {
+		trim(interned, 499);
+		interned.set(k, i = o);
+	}
+	return i;
+};
+/**
+* `{x, number|date|time, …}` (opcodes 4, 5, 6) and `#` (4 without options).
+* A missing value renders nothing, like a plain `{x}`: never the current
+* time, 1970 or "NaN" (`#` gets null when its plural has no value).
+*/
+function formatPart(op, options, value, scope) {
+	if (value == null) return "";
+	const o = options ? DEV ? intern(options) : options : NO_OPTIONS[op - 4];
+	let formatters = irCache.get(o);
+	if (!formatters) irCache.set(o, formatters = /* @__PURE__ */ new Map());
+	const { locale, timeZone: zone } = scope;
+	const k = locale + (op === 4 || !zone ? "" : "\0" + zone.toLowerCase());
+	let e = formatters.get(k);
+	if (!e) {
+		trim(formatters, 63);
+		formatters.set(k, e = op === 4 ? [new Intl.NumberFormat(locale, o)] : [new Intl.DateTimeFormat(locale, {
+			timeZone: zone,
+			...o
+		}), op === 6 || hasTime(o)]);
+	}
+	try {
+		const s = e[0].format(value);
+		return e[1] ? timeText(s, scope) : s;
+	} catch {
+		return String(value);
+	}
+}
+const plurals = /* @__PURE__ */ new Map();
+/** PluralRules in a fixed (locale, type) slot. */
+const pluralRules = (locale, ordinal) => {
+	let slot = plurals.get(locale);
+	if (!slot) plurals.set(locale, slot = []);
+	return slot[+ordinal] ??= new Intl.PluralRules(locale, { type: ordinal ? "ordinal" : "cardinal" });
+};
+const memo = /* @__PURE__ */ new Map();
+const stable = (o) => o ? Object.keys(o).sort().map((k) => k + ":" + JSON.stringify(o[k])).join() : "";
+/**
+* The formatter of `kind` for the scope's locale. Only date kinds depend on
+* the zone, and `df` puts it into their `kind`: with per-user zones, a key
+* holding it for every kind would churn the map and construct number
+* formatters per call.
+*/
+function cached(kind, scope, options, make) {
+	const key = kind + "\0" + scope.locale + "\0" + stable(options);
+	let f = memo.get(key);
+	if (f === void 0) {
+		trim(memo, 499);
+		memo.set(key, f = make(scope.locale));
+	}
+	return f;
+}
+const nf = (scope, kind, options, extra) => cached(kind, scope, options, (l) => new Intl.NumberFormat(l, {
+	...options,
+	...extra
+}));
+const df = (scope, kind, options) => cached(kind + (scope.timeZone ?? ""), scope, options, (l) => new Intl.DateTimeFormat(l, {
+	timeZone: scope.timeZone,
+	...options
+}));
+/**
+* A date input as every engine's Intl takes it, and the zone it is read in
+* (PLAN §4.2, INTERNALS §6 D208). Temporal values are recognised by their
+* tag, so native objects and a polyfill's alike, and converted everywhere:
+* Intl takes them only where the engine has Temporal (not Node 22), never a
+* ZonedDateTime, and only in the formatter's calendar, while a server and a
+* browser must render the same text for hydration. Exact times (Instant,
+* ZonedDateTime) become epoch ms, a ZonedDateTime read in its own zone;
+* wall-clock values (PlainDate, PlainDateTime, PlainTime, PlainYearMonth,
+* PlainMonthDay) become their ISO fields read in UTC, so no zone moves them.
+*/
+const instant = (value) => {
+	let v = value;
+	if (!String(v[Symbol.toStringTag]).startsWith("Temporal.")) return [value];
+	if (v.epochMilliseconds != null) return [v.epochMilliseconds, v.timeZoneId];
+	v = v.withCalendar?.("iso8601") ?? v;
+	return [Date.UTC(v.year ?? 1972, (v.monthCode?.slice(1) ?? 1) - 1, v.day ?? 1, v.hour ?? 0, v.minute ?? 0, v.second ?? 0, v.millisecond ?? 0), "UTC"];
+};
+/** The cached formatter for `value` (its own zone wins) and the value it formats. */
+const dt = (scope, kind, options, value) => {
+	const [v, zone] = instant(value);
+	return [df(scope, kind, zone ? {
+		...options,
+		timeZone: zone
+	} : options), v];
+};
+const fNumber = (scope, value, options) => nf(scope, "n", options).format(value);
+const fCurrency = (scope, value, currency, options) => nf(scope, "c" + currency, options, {
+	style: "currency",
+	currency
+}).format(value);
+/**
+* ISO 4217 list one: the minor unit of every code whose minor unit is not 2.
+* ISO gives the last group none (N.A.: precious metals, bond-market units,
+* XDR, XSU, XUA, XTS for testing, XXX for no currency), so an amount of them
+* counts whole units. Intl reports CLDR's display digits instead, which are
+* not ISO's and change with the ICU version (CLDR 48 shows COP, HUF, IDR and
+* PKR without decimals, CLDR 47 RSD), and browsers ship different ones: Intl
+* only formats.
+*/
+const MINOR_UNITS = {
+	BIF: 0,
+	CLP: 0,
+	DJF: 0,
+	GNF: 0,
+	ISK: 0,
+	JPY: 0,
+	KMF: 0,
+	KRW: 0,
+	PYG: 0,
+	RWF: 0,
+	UGX: 0,
+	UYI: 0,
+	VND: 0,
+	VUV: 0,
+	XAF: 0,
+	XOF: 0,
+	XPF: 0,
+	BHD: 3,
+	IQD: 3,
+	JOD: 3,
+	KWD: 3,
+	LYD: 3,
+	OMR: 3,
+	TND: 3,
+	CLF: 4,
+	UYW: 4,
+	XAG: 0,
+	XAU: 0,
+	XBA: 0,
+	XBB: 0,
+	XBC: 0,
+	XBD: 0,
+	XDR: 0,
+	XPD: 0,
+	XPT: 0,
+	XSU: 0,
+	XTS: 0,
+	XUA: 0,
+	XXX: 0
+};
+/**
+* Minor units: divided by the currency's ISO 4217 minor unit (JPY 0, USD 2,
+* BHD 3, `MINOR_UNITS`), never a fixed 100 nor CLDR's display digits, which
+* only decide what the output shows. Bigints become an exact decimal string,
+* which Intl formats without going through a double.
+*/
+const fCurrencyMinor = (scope, minor, currency, options) => {
+	const d = MINOR_UNITS[currency.toUpperCase()] ?? 2;
+	let value;
+	if (typeof minor === "bigint") {
+		const s = (minor < 0n ? -minor : minor).toString().padStart(d + 1, "0");
+		value = (minor < 0n ? "-" : "") + s.slice(0, s.length - d) + (d ? "." + s.slice(-d) : "");
+	} else value = minor / 10 ** d;
+	return fCurrency(scope, value, currency, options);
+};
+const fUnit = (scope, value, unit, options) => nf(scope, "u" + unit, options, {
+	style: "unit",
+	unit
+}).format(value);
+const fCompact = (scope, value, options) => nf(scope, "k", options, { notation: "compact" }).format(value);
+const fPercent = (scope, value, options) => nf(scope, "p", options, { style: "percent" }).format(value);
+const fDate = (scope, value, options) => {
+	const [f, v] = dt(scope, "d", options, value);
+	const s = f.format(v);
+	return options && hasTime(options) ? timeText(s, scope) : s;
+};
+const SHORT_TIME = { timeStyle: "short" };
+const fTime = (scope, value, options) => {
+	const [f, v] = dt(scope, "t", options ?? SHORT_TIME, value);
+	return timeText(f.format(v), scope);
+};
+const fDateRange = (scope, start, end, options) => {
+	const [f, a] = dt(scope, "d", options, start);
+	const s = f.formatRange(a, instant(end)[0]);
+	return options && hasTime(options) ? timeText(s, scope) : normalize(s);
+};
+const SECONDS = {
+	second: 1,
+	minute: 60,
+	hour: 3600,
+	day: 86400,
+	week: 604800,
+	month: 2629746,
+	quarter: 7889238,
+	year: 31556952
+};
+const AUTO_UNITS = [
+	"second",
+	"minute",
+	"hour",
+	"day",
+	"week",
+	"month",
+	"year"
+];
+const fRelative = (scope, value, options) => {
+	const { now, unit, ...rest } = options ?? {};
+	const seconds = (+(value.epochMilliseconds ?? value) - (now ?? scope.now ?? Date.now())) / 1e3;
+	let u = unit ? unit.replace(/s$/, "") : "";
+	if (!own(SECONDS, u)) {
+		const a = Math.abs(seconds);
+		let i = 0;
+		for (; i < 6; i++) {
+			const s = SECONDS[AUTO_UNITS[i]];
+			if (Math.max(a, Math.round(a / s) * s) < SECONDS[AUTO_UNITS[i + 1]]) break;
+		}
+		u = AUTO_UNITS[i];
+	}
+	return cached("r", scope, rest, (l) => new Intl.RelativeTimeFormat(l, rest)).format(Math.round(seconds / SECONDS[u]) + 0, u);
+};
+const fList = (scope, items, options) => cached("l", scope, options, (l) => new Intl.ListFormat(l, options)).format(items);
+const fCollator = (scope, options) => cached("o", scope, options, (l) => new Intl.Collator(l, options));
+const fCompare = (scope, a, b, options) => fCollator(scope, options).compare(a, b);
+const fSegment = (scope, text, options) => cached("g", scope, options, (l) => new Intl.Segmenter(l, options)).segment(text);
+const fDisplayName = (scope, code, options) => {
+	try {
+		return cached("y", scope, options, (l) => new Intl.DisplayNames(l, options)).of(code);
+	} catch {
+		return;
+	}
+};
+const DURATION_UNITS = [
+	"year",
+	"month",
+	"week",
+	"day",
+	"hour",
+	"minute",
+	"second",
+	"millisecond"
+];
+/**
+* `Intl.DurationFormat` where the engine has it; elsewhere (Node 22) unit
+* numbers joined by a unit list, which renders the same text for the common
+* styles (`1 hr, 30 min`), and `h:mm:ss` for `digital`.
+*/
+const fDuration = (scope, duration, options) => {
+	const style = options?.style ?? "short";
+	const DF = Intl.DurationFormat;
+	if (DF) return cached("D", scope, options, (l) => new DF(l, { style })).format(duration);
+	const parts = [];
+	const display = style === "digital" ? "short" : style;
+	const v = (u) => duration[u + "s"] ?? 0;
+	for (const u of DURATION_UNITS) {
+		if (style === "digital" && u === "hour") {
+			const two = nf(scope, "n", { minimumIntegerDigits: 2 });
+			parts.push(fNumber(scope, v("hour")) + ":" + two.format(v("minute")) + ":" + two.format(v("second") + v("millisecond") / 1e3));
+			break;
+		}
+		if (v(u)) parts.push(nf(scope, "U" + u + display, { unitDisplay: display }, {
+			style: "unit",
+			unit: u
+		}).format(v(u)));
+	}
+	if (!parts.length) parts.push(nf(scope, "Usecond" + display, { unitDisplay: display }, {
+		style: "unit",
+		unit: "second"
+	}).format(0));
+	return fList(scope, parts, {
+		type: "unit",
+		style: display === "long" ? "long" : display
+	});
+};
+//#endregion
+//#region src/runtime/format.ts
+/**
+* The IR interpreter (INTERNALS §2.3 "Interpretation"). Normative: the server
+* and the client must render byte-identical text, so every rule lives here
+* once and `rich.ts` reuses the helpers. Only plain text is rendered here:
+* `t()` ships this file, and the rich-text outputs (handlers, nodes, HTML
+* escaping) are `rich.ts`'s.
+*/
+/**
+* A value by argument name. Own properties only: a message argument named
+* `constructor` must not read `Object.prototype.constructor` off a values object.
+*/
+const valueOf = (values, name) => values && own(values, name) ? values[name] : void 0;
+/**
+* The case of a select (`String(value)`) or plural (`=N`, then the category)
+* part. `n` receives the `#` value of the case: the plural value minus the
+* offset, or the enclosing one for a select.
+*/
+function caseOf(part, value, locale) {
+	const cases = part[2];
+	let key = String(value);
+	if (part[1] > 1) {
+		const n = Number(value ?? NaN);
+		if (!own(cases, key = "=" + n)) key = pluralRules(locale, part[1] > 2).select(n - (part[3] ?? 0));
+	}
+	return own(cases, key) ? cases[key] : cases.other;
+}
+/** `#` value inside a plural case: the raw number minus the offset; null (nothing) without a value. */
+const poundOf = (part, value) => value == null ? null : Number(value) - (part[3] ?? 0);
+/** `{x, date, medium}`'s options (FormatJS's default `formats`), one object so its formatters are cached. */
+const MEDIUM = {
+	month: "short",
+	day: "numeric",
+	year: "numeric"
+};
+/**
+* Text of a plain `{arg}`: strings are bidi-isolated, numbers and bigints use
+* `String()` (FormatJS parity; `{n, number}` localises), a `Date` renders as
+* `{x, date, medium}` in the scope's locale and zone (`String(date)` is
+* English in the host's zone, so server and browser would disagree), null
+* and undefined render nothing.
+*/
+function argText(value, scope) {
+	if (typeof value === "string") return isolate(value, scope.locale);
+	if (value instanceof Date) return formatPart(5, MEDIUM, value, scope);
+	return String(value ?? "");
+}
+/**
+* Renders a compiled message as plain text in `scope` (tags render their
+* children). Recursion passes `n`, the `#` value of the innermost plural, and
+* `from`: tags reuse their own array from index 2, so no child list is ever
+* sliced.
+*/
+function formatMessage(message, values, scope, n = 0, from = 0) {
+	if (typeof message === "string") return message;
+	let out = "";
+	for (let i = from; i < message.length; i++) {
+		const p = message[i];
+		if (typeof p === "string") out += p;
+		else if (p === 0) out += formatPart(4, void 0, n, scope);
+		else {
+			const op = p[1];
+			if (op === 7) out += formatMessage(p, values, scope, n, 2);
+			else if (op !== 8) {
+				const value = valueOf(values, p[0]);
+				if (DEV && value == null && op !== 1) warnOnce(`no value for {${p[0]}} in ${JSON.stringify(message)}`);
+				if (op === void 0) out += argText(value, scope);
+				else if (op < 4) {
+					const c = caseOf(p, value, scope.locale);
+					if (c !== void 0) out += formatMessage(c, values, scope, op === 1 ? n : poundOf(p, value));
+				} else out += formatPart(op, p[2], value, scope);
+			}
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/runtime/t.ts
+/**
+* `t` and `msg` (PLAN §5.3, §5.12; INTERNALS §2.11.2). The hot path for a
+* plain string is: resolve the scope, one `Map.get`, one `typeof`.
+*/
+const { resolve, track: notify } = S;
+/**
+* The message to render for `key` in `scope`. `track` notifies the framework
+* trackers; translators bound to a fixed scope pass false.
+*/
+function lookup(scope, key, track) {
+	let text;
+	let d;
+	if (key && typeof key === "object") {
+		d = key;
+		text = d.message ?? d.id ?? "";
+	} else text = String(key);
+	const id = d?.id ?? scope.sources?.get(text) ?? text;
+	if (!quiet) scope.used?.add(id);
+	if (track) notify();
+	if (DEV) scope.seen?.(id);
+	if (!BUILD && scope.test) return scope.test(id, d, text);
+	if (DEV && d && d.h !== void 0 && d.ir !== void 0) {
+		const label = scope.labels?.get(id);
+		if (label !== void 0 && label !== d.h) {
+			warnOnce(`${id}: translation is for other text than ${JSON.stringify(d.message)}; run vi18n extract`);
+			S.missing(scope, id, "source-mismatch");
+			return d.ir;
+		}
+	}
+	const m = scope.messages.get(id) ?? d?.ir;
+	if (m !== void 0) return m;
+	S.missing(scope, id, "unknown-id");
+	if (DEV) {
+		warnOnce(`no message ${JSON.stringify(text)} in ${scope.locale}: unknown id, or a call the plugin did not process`);
+		return text;
+	}
+	return scope.kind === "page" && !S.serverResolver && S.registration?.consumer !== "server" ? "" : text;
+}
+const t = ((key, values) => {
+	const scope = resolve();
+	return formatMessage(lookup(scope, key, true), values, scope);
+});
+function msg(message) {
+	return message;
+}
+//#endregion
+export { fTime as C, fSegment as S, formatPart as T, fDuration as _, caseOf as a, fPercent as b, valueOf as c, fCompare as d, fCurrency as f, fDisplayName as g, fDateRange as h, argText as i, fCollator as l, fDate as m, msg as n, formatMessage as o, fCurrencyMinor as p, t as r, poundOf as s, lookup as t, fCompact as u, fList as v, fUnit as w, fRelative as x, fNumber as y };

package/dist/test.d.ts

@@ -0,0 +1,116 @@
+import { a as Message, y as Translator } from "./types-DsdWBG0b.js";
+//#region src/test/i18n.d.ts
+/** What every message renders as: its translation or source, its id, or pseudo text. */
+type TestMode = "source" | "ids" | "pseudo";
+/** One locale's translations from the project's catalogs (`loadCatalog`). */
+interface TestCatalog {
+  readonly locale: string;
+  /** Id → compiled message, fallbacks applied; untranslated ids are absent and render the source. */
+  readonly messages: ReadonlyMap<string, Message>;
+}
+interface TestI18nOptions {
+  /**
+   * The locale to render in (formatting, plural rules, `getLocale()`,
+   * `<html lang dir>`). Default: the catalog's, `en-XA` in pseudo mode, else
+   * the source locale.
+   */
+  locale?: string;
+  /** Default `"source"`: translations where given, the source text elsewhere. */
+  mode?: TestMode;
+  /** Real translations, from `await loadCatalog(locale)`. */
+  catalog?: TestCatalog;
+  /** Hand-written translations (ICU), keyed by id or by source text; they win over `catalog`. */
+  messages?: {
+    readonly [idOrSource: string]: string;
+  };
+  /** IANA zone for dates and times. Default `"UTC"`. */
+  timeZone?: string;
+  /** `fmt.relative`'s now. Default 2026-01-01T00:00:00Z. */
+  now?: number | Date;
+  /** Ids mode for calls the plugin did not rewrite: the generated id length (`ids.length`). Default 12. */
+  idLength?: number;
+}
+/** The API bound to the test scope, and the way back. */
+interface TestI18n extends Translator {
+  readonly mode: TestMode;
+  /** Restores what the first `createTestI18n` found (the plugin's source-locale default). */
+  reset(): void;
+}
+/** Puts the page back as the first `createTestI18n` found it. */
+export declare function resetTestI18n(): void;
+/**
+ * Renders every `t()` of the test in `options.locale` and `options.mode`
+ * until `reset()` (or the next `createTestI18n`, which replaces it). Without
+ * a call, tests under the plugin render the source locale as before.
+ */
+export declare function createTestI18n(options?: TestI18nOptions): TestI18n;
+//#endregion
+//#region src/test/catalog.d.ts
+interface LoadCatalogOptions {
+  /**
+   * Where to look for `vi18n.config.ts` (walking up). Default: the project
+   * the plugin resolved under Vitest, else the working directory.
+   */
+  root?: string;
+  /** The config file, relative to `root`. */
+  configFile?: string;
+}
+/**
+ * The locale's translations, fallbacks applied; untranslated and unusable
+ * entries are left out, so those messages render their source text, as in
+ * `vite dev`. Memoised per project and locale for the test file.
+ */
+export declare function loadCatalog(locale: string, options?: LoadCatalogOptions): Promise<TestCatalog>;
+//#endregion
+//#region src/test/pseudo.d.ts
+/**
+ * Pseudo-locale checks for browser tests (PLAN §4.14, §5.21; INTERNALS §6
+ * D193): `en-XA` and `ar-XB` bracket every rendered message, so on a page
+ * switched to one, letters outside any bracket pair are text that never went
+ * through `t()`. The page is typed by the two methods used, so Playwright's
+ * `Page` fits and nothing here depends on Playwright. This module imports no
+ * runtime: the scanners run in the test runner, the page has its own copy.
+ */
+/** What the helpers call on a Playwright `Page` (or anything with the same methods). */
+interface PseudoPage {
+  evaluate(fn: (arg: unknown) => unknown, arg?: unknown): Promise<unknown>;
+  waitForFunction(fn: (arg: unknown) => unknown, arg?: unknown, options?: {
+    timeout?: number;
+  }): Promise<unknown>;
+}
+interface PseudoLeak {
+  /** The run of text found outside brackets, allowed parts included. */
+  text: string;
+  /** Up to 10 characters on either side of it, for the failure message. */
+  context: string;
+}
+interface PseudoScanOptions {
+  /**
+   * Text that may legitimately appear outside brackets: user data, brand
+   * names. Each occurrence is cut out of a run and the rest is still checked,
+   * so allowing `Ann` does not hide the hard-coded `Welcome back,` next to it.
+   */
+  allow?: readonly (string | RegExp)[];
+  /** `scanPseudo` only: CSS selectors whose text is not checked, beside `[data-pseudo-ignore]`. */
+  ignore?: readonly string[];
+}
+/**
+ * Runs of letters at bracket depth 0 in `text`. The depth is per line: page
+ * text joins blocks with newlines, and a stray `]` in one block must not hide
+ * a leak in the next.
+ */
+export declare function findPseudoLeaks(text: string, options?: PseudoScanOptions): PseudoLeak[];
+/** Text outside pseudo brackets on the page as it is now; empty means clean. */
+export declare function scanPseudo(page: PseudoPage, options?: PseudoScanOptions): Promise<PseudoLeak[]>;
+/**
+ * Switches the page to a pseudo-locale through its own vi18n runtime
+ * (`setLocale`, in place or by navigation, as the app's routing does it) and
+ * waits until `<html lang>` names it and its strings are loaded. Pseudo-locales
+ * exist in `vite dev` and non-production builds that list them in
+ * `pseudoLocales`.
+ */
+export declare function setPseudoLocale(page: PseudoPage, locale?: "en-XA" | "ar-XB", options?: {
+  timeout?: number;
+}): Promise<void>;
+//#endregion
+export type { LoadCatalogOptions, PseudoLeak, PseudoPage, PseudoScanOptions, TestCatalog, TestI18n, TestI18nOptions, TestMode };