@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/engine.js

@@ -0,0 +1,1241 @@
+import { _ as DEV, c as page, d as resolved, f as setEngine, g as BUILD, i as created, n as S, o as nav, p as subs, r as changed, s as noop, t as textDirection, u as report, v as browser, x as warnOnce } from "./dir-zw6bGMKQ.js";
+import { a as hostLocale, d as splitLocalePath, i as awayHref, s as localizePath, t as ROUTES } from "./url-CsBkRaJy.js";
+import { a as strategyFor, i as readCookie, n as clientLocale, o as urlLocale, r as matchLocale, t as STORAGE_KEY } from "./match-BGr8EXB3.js";
+//#region src/runtime/devtools-protocol.ts
+/** Client → server: one translation to write. */
+const EDIT_EVENT = "vi18n:edit";
+/** Server → the client that asked: the outcome of one `EDIT_EVENT`. */
+const EDIT_RESULT_EVENT = "vi18n:edit-result";
+/**
+* The page global through which the dock, a same-origin iframe, reaches the
+* editor: it is a separate document with no module graph of its own.
+*/
+const BRIDGE$1 = "__vi18nDevtools";
+//#endregion
+//#region src/runtime/devtools.ts
+/**
+* In-context editing (PLAN §4.13 P2; INTERNALS §2.18), dev only. With
+* `devtools: true` the plugin's dev client boot calls `inContext`; nothing
+* else imports this module, so builds and a default dev server never carry
+* it (the engine entry exports it, and a side-effect import of the engine
+* tree-shakes it away).
+*
+* No marker reaches the DOM. The page scope's `seen` hook records every id
+* the page looks up, and a reverse index matches an element's text against
+* patterns compiled from the scope's messages: literal text exactly, every
+* argument as a wildcard, each select or plural case as an alternative.
+* Alt+click on text opens a card with the message's source, notes, state
+* and the locale's translation (from the dev server's `__vi18n/messages`);
+* saving sends `vi18n:edit` over Vite's HMR channel, and the catalog HMR
+* that follows the write re-renders the page. The Vite DevTools dock reaches
+* the editor through the `BRIDGE` global.
+*/
+const WILD = "[\\s\\S]*?";
+/** Collapses whitespace the way rendered text is compared. */
+const normalizeText = (text) => text.replace(/\s+/g, " ").trim();
+function literal(text, weight) {
+	weight.n += text.replace(/\s+/g, "").length;
+	return text.split(/\s+/).map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s*");
+}
+function partSource(part, weight) {
+	if (typeof part === "string") return literal(part, weight);
+	if (part === 0) return WILD;
+	const op = part[1];
+	if (op === 1 || op === 2 || op === 3) return `(?:${Object.values(part[2]).map((m) => messageSource(m, weight)).join("|")})`;
+	if (op === 7) return part.slice(2).map((p) => partSource(p, weight)).join("");
+	if (op === 8) return "";
+	return WILD;
+}
+function messageSource(message, weight) {
+	if (typeof message === "string") return literal(message, weight);
+	return message.map((part) => partSource(part, weight)).join("");
+}
+/**
+* The pattern a message's rendered text matches, and how much literal text
+* it pins down; null for a message that is only arguments, which any text
+* would match.
+*/
+function messagePattern(message) {
+	const weight = { n: 0 };
+	let source = messageSource(message, weight);
+	if (weight.n === 0) return null;
+	while (source.includes(WILD + WILD)) source = source.replaceAll(WILD + WILD, WILD);
+	return {
+		re: new RegExp(`^\\s*${source}\\s*$`),
+		weight: weight.n
+	};
+}
+/** A reverse index over one locale's messages, compiled on first use. */
+function reverseIndex(messages) {
+	let patterns;
+	return { match(text, prefer) {
+		const target = normalizeText(text);
+		if (target === "") return [];
+		patterns ??= [...messages].flatMap(([id, message]) => {
+			const pattern = messagePattern(message);
+			return pattern === null ? [] : [{
+				id,
+				...pattern
+			}];
+		});
+		const rank = (p) => (prefer?.has(p.id) ? 1e9 : 0) + p.weight;
+		return patterns.filter((p) => p.re.test(target)).sort((a, b) => rank(b) - rank(a)).map((p) => p.id);
+	} };
+}
+/** Text a user sees on an element besides its content. */
+const ATTRIBUTES = [
+	"placeholder",
+	"title",
+	"aria-label",
+	"alt",
+	"value"
+];
+/**
+* The messages behind the text at `target`: its attributes, then the text
+* of it and up to four ancestors, the innermost that matches winning (a
+* click on the `<b>` of a rich message finds the message on its parent).
+*/
+function locate(target, index, prefer) {
+	for (const name of ATTRIBUTES) {
+		const value = target.getAttribute(name);
+		const ids = value === null ? [] : index.match(value, prefer);
+		if (ids.length > 0) return {
+			element: target,
+			ids
+		};
+	}
+	let element = target;
+	for (let depth = 0; element !== null && depth < 5; depth++, element = element.parentElement) {
+		const text = element.textContent ?? "";
+		if (text.length > 4e3) break;
+		const ids = index.match(text, prefer);
+		if (ids.length > 0) return {
+			element,
+			ids
+		};
+	}
+	return null;
+}
+/** Space kept from the viewport's edges, and between the card and the text. */
+const MARGIN = 8;
+/** Below this, a side is too short for a card that scrolls inside. */
+const MIN_HEIGHT = 120;
+const clamp = (value, low, high) => Math.max(low, Math.min(value, high));
+/**
+* Places a `card`-sized box next to `anchor` (the clicked text) inside the
+* viewport without covering it: below when the card fits there, else above,
+* else on the roomier of the two with the card scrolling inside, else beside
+* the text when it is too tall for either; only text taller and wider than
+* the viewport allows leaves the card over part of it.
+*/
+function placeCard(anchor, card, viewport) {
+	const below = viewport.height - MARGIN - (anchor.bottom + MARGIN);
+	const above = anchor.top - MARGIN - MARGIN;
+	const left = clamp(anchor.left, MARGIN, viewport.width - MARGIN - card.width);
+	const vertical = (side, room) => {
+		const height = Math.min(card.height, room);
+		const top = side === "below" ? anchor.bottom + MARGIN : anchor.top - MARGIN - height;
+		return {
+			top: clamp(top, MARGIN, viewport.height - MARGIN - height),
+			left,
+			maxHeight: card.height > room ? room : null
+		};
+	};
+	if (card.height <= below) return vertical("below", below);
+	if (card.height <= above) return vertical("above", above);
+	if (Math.max(below, above) >= MIN_HEIGHT) return below >= above ? vertical("below", below) : vertical("above", above);
+	const right = viewport.width - MARGIN - (anchor.right + MARGIN);
+	const before = anchor.left - MARGIN - MARGIN;
+	const room = viewport.height - 16;
+	const top = clamp(anchor.top, MARGIN, viewport.height - MARGIN - Math.min(card.height, room));
+	const maxHeight = card.height > room ? room : null;
+	if (right >= card.width) return {
+		top,
+		left: anchor.right + MARGIN,
+		maxHeight
+	};
+	if (before >= card.width) return {
+		top,
+		left: anchor.left - MARGIN - card.width,
+		maxHeight
+	};
+	return {
+		top: viewport.height - MARGIN - Math.min(card.height, MIN_HEIGHT),
+		left,
+		maxHeight: card.height > MIN_HEIGHT ? MIN_HEIGHT : null
+	};
+}
+const STYLE = `
+:host { all: initial; }
+.box { position: fixed; z-index: 2147483647; pointer-events: none; outline: 2px solid #7c3aed; border-radius: 2px; }
+.card { position: fixed; z-index: 2147483647; width: min(380px, calc(100vw - 16px)); max-height: min(70vh, 560px); overflow: auto;
+  box-sizing: border-box; padding: 12px; border-radius: 8px; border: 1px solid #8884; box-shadow: 0 8px 24px #0004;
+  font: 13px/1.4 system-ui, sans-serif; color-scheme: light dark; background: Canvas; color: CanvasText; }
+.row { display: flex; gap: 8px; align-items: center; margin-top: 8px; }
+.grow { flex: 1; }
+code, pre, textarea { font: 12px/1.4 ui-monospace, monospace; }
+pre { margin: 4px 0 0; padding: 6px; white-space: pre-wrap; word-break: break-word; border-radius: 4px; background: #8881; }
+textarea { box-sizing: border-box; width: 100%; min-height: 64px; margin-top: 4px; padding: 6px; resize: vertical; color: inherit; background: transparent; border: 1px solid #8886; border-radius: 4px; }
+.muted { opacity: .7; }
+.badge { padding: 0 6px; border-radius: 9px; font-size: 11px; background: #8882; }
+.missing { background: #f973; } .ai { background: #38f3; } .translated { background: #2a63; }
+.problem { margin-top: 6px; color: #d33; } .problem.warning { color: #b80; }
+button { font: inherit; padding: 2px 10px; border-radius: 4px; border: 1px solid #8886; color: inherit; background: #8881; cursor: pointer; }
+button:disabled { opacity: .5; cursor: default; }
+ul { margin: 6px 0 0; padding: 0; list-style: none; } li { padding: 2px 0; cursor: pointer; } li:hover { text-decoration: underline; }
+`;
+function h(tag, props = {}, ...children) {
+	const element = document.createElement(tag);
+	for (const [key, value] of Object.entries(props)) if (key.startsWith("on")) element.addEventListener(key.slice(2), value);
+	else element[key] = value;
+	for (const child of children) if (child !== null && child !== false) element.append(child);
+	return element;
+}
+/** Moves an installed editor to the `hot` of a boot module that ran again. */
+let attach;
+/**
+* Installs the editor on the page: the `seen` recorder on the page scope,
+* the Alt+click listener, the HMR reply listener and the dock's bridge.
+* Called by the plugin's dev client boot (`devtools: true`) with its
+* `import.meta.hot`; a no-op outside a document or without HMR.
+*/
+function inContext(hot, endpoint) {
+	if (hot === void 0 || typeof document !== "object") return;
+	if (attach !== void 0) return attach(hot);
+	const page = S.resolve();
+	const seen = /* @__PURE__ */ new Set();
+	page.seen = (id) => {
+		seen.add(id);
+	};
+	let indexed;
+	let index = reverseIndex(/* @__PURE__ */ new Map());
+	const currentIndex = () => {
+		if (indexed !== page.messages) index = reverseIndex(indexed = page.messages);
+		return index;
+	};
+	let nonce = 0;
+	const waiting = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let channel = hot;
+	attach = (next) => {
+		channel = next;
+		next.on(EDIT_RESULT_EVENT, (result) => {
+			waiting.get(result.nonce)?.(result);
+			waiting.delete(result.nonce);
+		});
+		next.on("vi18n:catalog-update", () => {
+			for (const listener of listeners) listener();
+		});
+	};
+	attach(hot);
+	const save = (request) => new Promise((done) => {
+		waiting.set(++nonce, done);
+		channel.send(EDIT_EVENT, {
+			...request,
+			nonce
+		});
+	});
+	const load = async (ids) => {
+		const query = new URLSearchParams({ locale: page.locale });
+		for (const id of ids) query.append("id", id);
+		const response = await fetch(`${endpoint}?${query}`, { cache: "no-store" });
+		if (!response.ok) throw new Error(`${endpoint} answered ${response.status}`);
+		return await response.json();
+	};
+	const host = document.createElement("div");
+	host.setAttribute("data-vi18n-devtools", "");
+	const root = host.attachShadow({ mode: "open" });
+	root.append(h("style", { textContent: STYLE }));
+	const box = h("div", { className: "box" });
+	const card = h("div", { className: "card" });
+	/** The text the card belongs to; null when the dock opened it. */
+	let anchor = null;
+	const close = () => {
+		anchor = null;
+		box.remove();
+		card.remove();
+	};
+	const place = () => {
+		if (anchor === null || !card.isConnected) return;
+		if (!anchor.isConnected) {
+			box.remove();
+			return;
+		}
+		const rect = anchor.getBoundingClientRect();
+		Object.assign(box.style, {
+			top: `${rect.top - 2}px`,
+			left: `${rect.left - 2}px`,
+			width: `${rect.width + 4}px`,
+			height: `${rect.height + 4}px`
+		});
+		card.style.maxHeight = "";
+		const at = placeCard(rect, card.getBoundingClientRect(), {
+			width: innerWidth,
+			height: innerHeight
+		});
+		Object.assign(card.style, {
+			top: `${at.top}px`,
+			left: `${at.left}px`,
+			maxHeight: at.maxHeight === null ? "" : `${at.maxHeight}px`
+		});
+	};
+	new ResizeObserver(place).observe(card);
+	const show = async (ids, at) => {
+		const id = ids[at];
+		let data;
+		try {
+			data = await load([id]);
+		} catch (error) {
+			card.replaceChildren(h("div", { className: "problem" }, String(error)));
+			return;
+		}
+		const message = data.messages[0];
+		if (message === void 0) {
+			card.replaceChildren(h("div", {}, h("code", {}, id), " is not a message the dev server knows."));
+			return;
+		}
+		const area = h("textarea", {
+			value: message.text,
+			readOnly: !data.editable,
+			placeholder: data.editable ? "Untranslated" : ""
+		});
+		const problems = h("div");
+		const button = h("button", {
+			textContent: "Save",
+			disabled: !data.editable,
+			onclick: async () => {
+				button.disabled = true;
+				const result = await save({
+					id,
+					locale: data.locale,
+					source: message.source,
+					expected: message.text,
+					translation: area.value
+				});
+				button.disabled = false;
+				problems.replaceChildren(...result.problems.map((p) => h("div", { className: `problem ${p.severity}` }, `${p.code}: ${p.message}`)));
+				if (result.ok && result.problems.length === 0) close();
+			}
+		});
+		area.addEventListener("keydown", (event) => {
+			if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) button.click();
+		});
+		const list = h("ul", { hidden: true });
+		const listButton = h("button", {
+			textContent: `Page messages (${seen.size})`,
+			onclick: async () => {
+				list.hidden = !list.hidden;
+				if (list.hidden) return;
+				const all = await load([...seen]);
+				list.replaceChildren(...all.messages.map((m) => h("li", { onclick: () => void show([m.id], 0) }, h("span", { className: `badge ${m.state}` }, m.reason ?? m.state), " ", m.text || m.source)));
+			}
+		});
+		const step = (by) => h("button", {
+			textContent: by < 0 ? "‹" : "›",
+			disabled: at + by < 0 || at + by >= ids.length,
+			onclick: () => void show(ids, at + by)
+		});
+		card.replaceChildren(h("div", { className: "row" }, h("code", { className: "grow" }, id), h("span", { className: `badge ${message.state}` }, message.reason ?? message.state), h("span", { className: "muted" }, data.locale), h("button", {
+			textContent: "×",
+			title: "Close (Esc)",
+			onclick: close
+		})), h("div", { className: "muted" }, "Source"), h("pre", {}, message.source), message.contexts.length > 0 ? h("div", { className: "muted" }, message.contexts.join(" · ")) : "", h("div", { className: "muted" }, [message.at, message.file].filter(Boolean).join(" → "), message.maxLength === null ? "" : ` · max ${message.maxLength}`), data.editable ? area : h("div", { className: "muted" }, data.locale === data.sourceLocale ? "The source locale's text is the code's: edit the call." : `${data.locale} has no catalog of its own.`), problems, h("div", { className: "row" }, button, ids.length > 1 && step(-1), ids.length > 1 && `${at + 1}/${ids.length}`, ids.length > 1 && step(1), h("span", { className: "grow" }), listButton), list);
+	};
+	const open = (element, ids) => {
+		if (!host.isConnected) document.body.append(host);
+		anchor = element;
+		if (element === null) {
+			box.remove();
+			Object.assign(card.style, {
+				top: "8px",
+				left: `${Math.max(8, innerWidth - 396)}px`,
+				maxHeight: ""
+			});
+			root.append(card);
+			show(ids, 0);
+			return;
+		}
+		root.append(box, card);
+		place();
+		show(ids, 0);
+	};
+	document.addEventListener("click", (event) => {
+		if (!event.altKey || event.composedPath().includes(host)) return;
+		const target = event.target;
+		if (!(target instanceof Element)) return;
+		const found = locate(target, currentIndex(), seen);
+		if (found === null) return;
+		event.preventDefault();
+		event.stopPropagation();
+		open(found.element, found.ids);
+	}, true);
+	document.addEventListener("keydown", (event) => {
+		if (event.key === "Escape") close();
+	});
+	addEventListener("scroll", place, {
+		passive: true,
+		capture: true
+	});
+	addEventListener("resize", place, { passive: true });
+	globalThis[BRIDGE$1] = {
+		locale: () => page.locale,
+		seen: () => [...seen],
+		open: (id) => open(null, [id]),
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		}
+	};
+}
+//#endregion
+//#region src/runtime/fetch.ts
+/**
+* The same-origin `fetch` wrapper (PLAN §5.12): server functions, actions and
+* API calls learn the tab's locale from `x-vi18n-locale`, per tab and without
+* a shared cookie. It wraps once, when the runtime evaluates, because the boot
+* import runs before framework runtimes that keep their own `fetch` reference.
+*/
+/**
+* `header()` returns the locale to send, or null to leave requests alone.
+* Browser only (the engine calls it in a document or a module worker), where
+* `fetch`, `Request` and `location` always exist.
+*/
+function wrapFetch(header) {
+	const original = globalThis.fetch;
+	const wrapped = (input, init) => {
+		const locale = header();
+		if (locale) try {
+			if (new URL(input.url ?? input, BUILD || browser() ? document.baseURI : location.href).origin === location.origin) {
+				const headers = new Headers(init?.headers ?? input.headers);
+				if (!headers.has("x-vi18n-locale")) {
+					headers.set("x-vi18n-locale", locale);
+					init = {
+						...init,
+						headers
+					};
+				}
+			}
+		} catch {}
+		return original(input, init);
+	};
+	try {
+		globalThis.fetch = wrapped;
+	} catch {
+		if (!Reflect.defineProperty(globalThis, "fetch", {
+			value: wrapped,
+			writable: true,
+			configurable: true
+		}) && DEV) warnOnce("fetch is read-only here, so requests carry no x-vi18n-locale");
+	}
+	return BUILD ? noop : () => {
+		if (globalThis.fetch === wrapped) globalThis.fetch = original;
+	};
+}
+//#endregion
+//#region src/runtime/navigation.ts
+/**
+* Navigation watcher (INTERNALS §2.11.7): a client-router navigation to a URL
+* in another locale (a plain `<a href="/de/pricing">`) switches the page in
+* place, so the router renders the new route with the new strings loaded.
+*/
+/**
+* Calls `onChange` after every same-document navigation committed, when
+* `location` is the new URL. Browser only (the engine calls it in a
+* document), where `history` exists.
+*/
+function watchNavigation(onChange) {
+	const nav = globalThis.navigation;
+	if (nav?.currentEntry) {
+		nav.addEventListener("currententrychange", onChange);
+		return;
+	}
+	for (const name of ["pushState", "replaceState"]) {
+		const original = history[name];
+		history[name] = function(...args) {
+			const r = original.apply(this, args);
+			onChange();
+			return r;
+		};
+	}
+	addEventListener("popstate", onChange);
+}
+//#endregion
+//#region src/runtime/loader.ts
+/**
+* The client engine behind the global state (INTERNALS §2.11): registration,
+* bundle loading, skew handling, locale switching, the navigation watcher,
+* the `fetch` wrapper and persistence. Only `@menapo/vi18n/engine` imports
+* it, and the generated client boot module imports that entry first; it
+* hooks into the core's `register` and replaces the inert client methods
+* `state.ts` installs, so neither the `.` entry nor `/server` carries it.
+*
+* Its data is private to the runtime copy that created the state; every
+* public export reaches it through the state's methods, so a second copy never
+* reads its own empty variables. Module-level variables rather than one
+* object, and one-letter fields on `LocaleData`: the minifier renames
+* variables but never properties, and this file is most of the engine's
+* 3.5 KB budget (PLAN §6).
+*/
+const own = Object.hasOwn;
+/**
+* `ssr.payload: "preload"` compiled in (the plugin's `__VI18N_PRELOAD__`):
+* default builds fold its branch out (PLAN §6), code bundled without the
+* plugin keeps it.
+*/
+const PRELOAD = typeof __VI18N_PRELOAD__ === "undefined" || !!__VI18N_PRELOAD__;
+/**
+* `output.compactIds` (the plugin's `__VI18N_COMPACT__`): bundle files are
+* arrays of messages, mapped to ids through the version's `ids.<v>.json`.
+* Folded out of default builds; undefined is false, as only the plugin's
+* boot module imports this engine.
+*/
+const COMPACT = typeof __VI18N_COMPACT__ !== "undefined" && !!__VI18N_COMPACT__;
+/**
+* `output.perLocale` (the plugin's `__VI18N_INLINE__`): chunks add the
+* messages they inline through `add`. Folded out of default builds.
+*/
+const INLINE = typeof __VI18N_INLINE__ !== "undefined" && !!__VI18N_INLINE__;
+const { setLocale: clientOnly } = S;
+let reg;
+const locs = /* @__PURE__ */ new Map();
+/** Message-set version the page booted with. */
+let version;
+let inline;
+/** `output.compactIds`: the version's key → ids, fetched once and shared by every locale. */
+let order;
+/** Ids the page looked up and missed: the merge that brings one re-renders (§6 D43). */
+const missed = /* @__PURE__ */ new Set();
+/** Loads `ready()` waits for. */
+const inflight = /* @__PURE__ */ new Set();
+/** Bumped per switch, so a slow earlier `setLocale` cannot flip after a later one. */
+let switches = 0;
+/**
+* The locale a URL-driven switch is loading, set exactly while one is
+* pending: the URL names it, or a clicked link is about to, so the new
+* page's route guards load their strings in it. Requests carry it once the
+* URL names it (§6 D108).
+*/
+let heading;
+/** The pending switch's loading: true once complete, false when a later switch took over. */
+let loading;
+/** The path of the last commit the watcher saw. */
+let committed;
+let watching;
+/** Restores the original `fetch`: Vitest registrations must not see the wrapper. */
+let unwrap = noop;
+const loc = (l) => {
+	let d = locs.get(l);
+	if (!d) locs.set(l, d = {
+		m: /* @__PURE__ */ new Map(),
+		k: /* @__PURE__ */ new Set(),
+		p: /* @__PURE__ */ new Map()
+	});
+	return d;
+};
+const error = (text, extra) => Object.assign(/* @__PURE__ */ new Error("vi18n: " + text), extra);
+const parse = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+};
+const setCookie = (name, value, maxAge) => {
+	document.cookie = name + "=" + encodeURIComponent(value) + "; Path=/; Max-Age=" + maxAge + "; SameSite=Lax";
+};
+const byId = (id) => BUILD || browser() ? parse(document.querySelector("script#" + id)?.textContent) : null;
+const abs = (url) => BUILD || browser() ? new URL(url, document.baseURI).href : url;
+const assets = () => reg?.assetsUrl ?? inline?.assetsUrl ?? "";
+/** A bundle's URL, and with `key` = "manifest" a manifest slice's (§2.9.5). */
+const bundleUrl = (l, key, hash) => abs(assets() + l + "/" + key + "." + hash + ".json");
+const stableUrl = (l) => abs((reg?.manifestUrl ?? inline?.manifestUrl ?? "").replace("{locale}", l));
+const STABLE = { cache: "no-cache" };
+const request = globalThis.fetch;
+/**
+* JSON from a boot-stub fetch (each consumed once) or the network. Anything
+* but an object is a 404: hosts with an SPA fallback (Netlify, Vercel or
+* Cloudflare Pages rewrites, Firebase) answer a file a deploy removed with
+* `200 index.html`, which must take the stable-manifest path like a 404,
+* never become a bundle.
+*/
+async function json(url, init) {
+	const fetches = S.boot?.fetches;
+	const pending = fetches?.[url];
+	let data;
+	let status = 404;
+	if (pending) {
+		delete fetches[url];
+		data = await pending;
+	} else {
+		const r = await request(url, init);
+		if (r.ok) data = await r.json().catch(noop);
+		else status = r.status;
+	}
+	if (!data || typeof data !== "object") throw error(status + " " + url, { status });
+	return data;
+}
+/**
+* The one skew decision (PLAN §5.11): the first version read is the page's;
+* a later manifest or payload of another version belongs to another deploy,
+* and its bundles are never mixed with ours.
+*/
+function checkVersion(v) {
+	if ((version ??= v) !== v) throw error("skew " + v, { skew: 1 });
+}
+/** Merges into a new Map; re-renders only when it repairs a recorded miss. */
+function merge(l, data) {
+	const d = loc(l);
+	const isPage = page.locale === l;
+	const m = new Map(d.m);
+	let repaired = false;
+	for (const b of data) for (const id in b) if (own(b, id)) {
+		m.set(id, b[id]);
+		if (isPage && missed.delete(id)) repaired = true;
+	}
+	d.m = m;
+	if (isPage) {
+		page.messages = m;
+		if (repaired) changed(true);
+	}
+}
+/**
+* Adopts a payload's bundles (marked loaded) and fallback-mode messages, and
+* starts the bundles it preloads (`ssr.payload: "preload"`): the page's
+* `<link rel="preload">` already fetches them, so this fetch takes those
+* responses, and a bundle no guard asks for soon is still used.
+*/
+function adopt(p) {
+	const d = loc(p.locale);
+	const data = [];
+	for (const k in p.bundles) if (own(p.bundles, k)) {
+		d.k.add(k);
+		data.push(p.bundles[k]);
+	}
+	data.push(p.messages);
+	merge(p.locale, data);
+	if (PRELOAD && p.preload) load(p.locale, p.preload).catch(noop);
+}
+/**
+* The page payload's zone, `now` and manifest, so islands hydrate as the
+* server rendered them (PLAN §5.13): the boot page's, then each one a
+* document-swapping router (Astro's) brings in with the next page. Builds
+* run it through `adoptLate`, with the payload's bundles; dev, which adopts
+* no payload, from `boot`.
+*/
+function hydrate(p) {
+	if (p.manifest) {
+		const d = loc(p.locale);
+		d.h = p.manifest;
+		d.r ??= resolved;
+	}
+	try {
+		Intl.DateTimeFormat(void 0, { timeZone: p.timeZone });
+		page.timeZone = p.timeZone;
+	} catch {}
+	page.now = p.now;
+	page.timeZoneSource = "client";
+}
+/**
+* Payloads not read yet, each adopted once: the page payload (boot's, then
+* that of each page a document-swapping router brings in) and late ones
+* (ids recorded after `</head>` was flushed). Each element is marked read
+* with an expando property: no attribute changes a hydrating framework
+* could see, and fewer bytes than a `WeakSet`. The mark comes after the
+* version check, so another deploy's payload fails every later load, as it
+* failed the first, instead of leaving its keys unknown and its strings empty.
+*/
+function adoptLate() {
+	if (!(BUILD || browser())) return;
+	for (const el of document.querySelectorAll("script#__vi18n,script[data-vi18n-late]")) {
+		const p = el.vi18n ? null : parse(el.textContent);
+		if (p) {
+			if (p.v != null) checkVersion(p.v);
+			if (el.id) hydrate(p);
+			adopt(p);
+		}
+		el.vi18n = 1;
+	}
+}
+function setDev(l, catalog) {
+	const d = loc(l);
+	d.m = new Map(Object.entries(catalog.messages ?? {}));
+	d.labels = new Map(Object.entries(catalog.labels ?? {}));
+	if (page.locale === l) {
+		page.messages = d.m;
+		page.labels = d.labels;
+	}
+}
+function devCatalog(l) {
+	const d = loc(l);
+	const catalogs = reg?.catalogs;
+	return d.r ??= catalogs && own(catalogs, l) ? catalogs[l]().then((m) => setDev(l, m.default), (e) => {
+		d.r = void 0;
+		if (DEV) console.error("vi18n: loading the " + l + " catalog failed", e);
+	}) : resolved;
+}
+/**
+* Settles once the locale's `{ key: hash }` map is in `d.h`, acquired once
+* from the first source that applies (§2.11.1); a page payload's map comes
+* through `hydrate`.
+*/
+function manifest(l) {
+	const d = loc(l);
+	return d.r ??= acquire(l).then((h) => d.h = h, (e) => {
+		d.r = void 0;
+		throw e;
+	});
+}
+async function acquire(l) {
+	const b = S.boot;
+	if (b?.locale === l && b.manifest) return b.manifest;
+	const entry = inline?.locales[l];
+	if (entry) return inline.kind === "full" ? entry : slice(l, bundleUrl(l, "manifest", entry.slice));
+	return slice(l, stableUrl(l), STABLE);
+}
+const pause = () => new Promise((r) => setTimeout(r, 250));
+/**
+* A manifest slice, retried once after 250 ms like bundles (a boot-stub
+* entry is consumed by the first try, so the retry goes to the network). A
+* 404 means a translation-only deploy replaced the hashed slice the HTML
+* names: the stable slice is the current one, and `checkVersion` decides
+* whether its bundles may still be mixed with ours.
+*/
+async function slice(l, url, init) {
+	let s;
+	try {
+		s = await json(url, init);
+	} catch (e) {
+		await pause();
+		const gone = e.status === 404;
+		s = await json(gone ? stableUrl(l) : url, gone ? STABLE : init);
+	}
+	checkVersion(s.v);
+	if (s.c && (BUILD || browser())) for (const e of document.querySelectorAll("[rel=modulepreload]")) {
+		const keys = s.c[e.href.split("/").pop()];
+		if (keys) load(l, keys).catch(noop);
+	}
+	return s.bundles;
+}
+/**
+* One bundle, retried once after 250 ms. A 404 means the hash moved (a
+* translation-only deploy): the stable slice gives the new hashes while its
+* version is still ours, and a skew error otherwise.
+*/
+async function bundle(l, key, d) {
+	try {
+		return await json(bundleUrl(l, key, d.h[key]));
+	} catch (e) {
+		await pause();
+		if (e.status === 404) {
+			if (!own(d.h = await slice(l, stableUrl(l), STABLE), key)) return {};
+		}
+		return await json(bundleUrl(l, key, d.h[key]));
+	}
+}
+/**
+* `ids.<v>.json`, fetched once per page, in parallel with the first array
+* bundle, retried once like bundles; a failure is forgotten so the next load
+* tries again. Every array bundle of this version maps through it: `v`
+* covers each key's ids (INTERNALS §2.9.3).
+*/
+function ids() {
+	const url = abs(assets() + "ids." + version + ".json");
+	return order ??= json(url).catch(() => pause().then(() => json(url))).catch((e) => {
+		order = void 0;
+		throw e;
+	});
+}
+/**
+* An array bundle's messages under their ids; positions without a message
+* (`null`) stay out. Null-prototype, so an id named `__proto__` is a key.
+*/
+function zip(keys = [], values) {
+	const b = Object.create(null);
+	keys.forEach((id, i) => {
+		if (values[i] != null) b[id] = values[i];
+	});
+	return b;
+}
+async function fetchKeys(l, keys, d) {
+	await manifest(l);
+	adoptLate();
+	const todo = (k) => !d.k.has(k) && own(d.h, k);
+	if ((BUILD || browser()) && document.readyState === "loading" && keys.some(todo)) {
+		await new Promise((r) => document.addEventListener("DOMContentLoaded", r));
+		adoptLate();
+	}
+	await Promise.all(keys.filter(todo).map((k) => {
+		let p = d.p.get(k);
+		if (!p) d.p.set(k, p = (COMPACT ? Promise.all([bundle(l, k, d), ids()]).then(([b, o]) => Array.isArray(b) ? zip(o[k], b) : b) : bundle(l, k, d)).then((b) => {
+			d.k.add(k);
+			merge(l, [b]);
+		}).finally(() => d.p.delete(k)));
+		return p;
+	}));
+}
+/** Registers a load `ready()` waits for. */
+function inFlight(p) {
+	inflight.add(p);
+	const done = () => inflight.delete(p);
+	p.then(done, done);
+	return p;
+}
+/** Loads `keys` of locale `l`; dev and server catalogs are complete and resolve at once. */
+function load(l, keys) {
+	if (!reg || !BUILD && reg.consumer !== "client") return resolved;
+	return inFlight(!BUILD && reg.mode === "dev" ? devCatalog(l) : fetchKeys(l, keys, loc(l)));
+}
+/**
+* Vite's reload contract for failed route loads: a cancelable
+* `vite:preloadError` whose `payload` is the error, so apps' existing
+* reload-on-deploy handlers cover vi18n's skew too.
+*/
+function preloadError(e) {
+	if (BUILD || browser()) {
+		const ev = new Event("vite:preloadError", { cancelable: true });
+		ev.payload = e;
+		if (!dispatchEvent(ev)) return;
+	}
+	throw e;
+}
+/**
+* Loads `keys` for the page the router is about to render. Under a URL-driven
+* switch that is the switch's locale, and the guard also waits for the rest
+* of it, so the route renders after the flip (routers that push first) or the
+* URL commit flips at once (routers that load first); never in the old
+* locale under the new URL. Until the URL names that locale, the page's
+* locale loads them too: no event tells a clicked link the router follows
+* from one a blocker stopped or the browser downloads, and the caller may be
+* a lazy part of the page still showing (§2.11.7). A switch that was
+* cancelled, or that flipped to another locale meanwhile, sends it round again.
+*/
+async function want(keys) {
+	const l = heading ?? page.locale;
+	await Promise.all([load(l, keys), l === sure() || load(page.locale, keys)]);
+	if (l === heading ? !await loading : l !== page.locale) return want(keys);
+}
+const need = (keys) => keys.length ? want(keys).catch(preloadError) : resolved;
+function flip(l) {
+	const d = loc(l);
+	page.locale = l;
+	page.messages = d.m;
+	page.labels = d.labels;
+	missed.clear();
+	if (BUILD || browser()) Object.assign(document.documentElement, {
+		lang: l,
+		dir: textDirection(l)
+	});
+}
+/**
+* The engine's half of `register`: the core already recorded the
+* registration, filled `locales` and set the page scope to the source locale.
+*/
+function boot(r) {
+	reg = r;
+	if (!BUILD && r.test) {
+		unwrap();
+		return devCatalog(r.config.sourceLocale);
+	}
+	if (!BUILD && r.consumer !== "client") return resolved;
+	if (!BUILD && !browser() && globalThis.WorkerGlobalScope) return worker(r);
+	if (ROUTES && r.config.routing.domains && (BUILD || browser())) r.config.routing.home = hostLocale(location.host, r.config);
+	const p = byId("__vi18n");
+	const n = BUILD ? navigator : globalThis.navigator;
+	const l = [p?.locale, S.boot?.locale].find((x) => S.locales.includes(x)) ?? clientLocale(r.config, {
+		pathname: BUILD || browser() ? location.pathname : "/",
+		cookie: BUILD || browser() ? document.cookie : "",
+		storage: (k) => localStorage.getItem(k),
+		languages: BUILD ? navigator.languages ?? [navigator.language] : n?.languages ?? [n?.language]
+	}).locale;
+	if (p && !BUILD && r.mode === "dev") hydrate(p);
+	flip(l);
+	if (BUILD || browser()) {
+		const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+		if (tz && readCookie(document.cookie, "vi18n_tz") !== tz) setCookie("vi18n_tz", tz, 31536e3);
+		if (BUILD || !watching) {
+			watching = true;
+			committed = location.pathname;
+			watchNavigation(onNavigate);
+			addEventListener("click", onClick, true);
+		}
+	}
+	if (!BUILD && r.mode === "dev") return inFlight(devCatalog(l));
+	const m = r.manifest;
+	inline = m && typeof m === "object" ? m : byId("__vi18n_manifest");
+	version = p?.v ?? S.boot?.v ?? inline?.v;
+	try {
+		adoptLate();
+	} catch {}
+	inFlight(manifest(l)).catch(noop);
+	return resolved;
+}
+/** Whether `path`'s strategy chain lists `strategy`. */
+const lists = (path, strategy) => strategyFor(reg.config, path).includes(strategy);
+/** The locale `path` names where the URL decides the locale, else null. */
+const named = (path) => lists(path, "url") ? urlLocale(reg.config, path) : null;
+/**
+* The locale the URL settles: `heading` once the URL names it, else the
+* page's. A clicked link decides nothing before its commit: the router may
+* still redirect, a blocker may stop it, or the browser downloads it.
+*/
+const sure = () => heading && named(location.pathname) === heading ? heading : page.locale;
+/** The current URL in `l` on the host serving it, when that is another listed host (§6 D135). */
+const away = (l) => awayHref(splitLocalePath(location.pathname, reg.config).path, l, reg.config);
+/**
+* The current URL in locale `l`, path-absolute (what client routers accept),
+* or absolute on another listed host.
+*/
+const hrefIn = (l) => (ROUTES && away(l) || localizePath(location.pathname, l, reg.config)) + location.search + location.hash;
+function persist(l) {
+	if (!(BUILD || browser())) return;
+	const { name, maxAge } = reg.config.routing.cookie;
+	setCookie(name, l, maxAge);
+	if (lists(location.pathname, "localStorage")) try {
+		localStorage.setItem(STORAGE_KEY, l);
+	} catch {}
+}
+/**
+* Loads `href` as a new document. Assigning the current URL is a same-document
+* fragment navigation when it has a `#hash` (no reload, so the locale would
+* never change), hence a reload when only the fragment could differ.
+*
+* Nothing records that the page is leaving: the watcher sees commits only,
+* so this navigation never reaches it, and a page that stays (restored from
+* the back/forward cache, or a `beforeunload` prompt cancelled the unload)
+* must keep switching on its next navigation. A switch started in the
+* moments before the unload only loads what the next document loads again.
+*/
+function go(href) {
+	const u = new URL(href, location.href);
+	u.hash = location.hash;
+	if (u.href === location.href) location.reload();
+	else location.assign(href);
+}
+/** A document navigation: nothing half-switched is ever shown (§6 D47). */
+function leave(l) {
+	persist(l);
+	go(hrefIn(l));
+}
+/**
+* Starts switch number `++switches`: loads `l` for every key the page uses.
+* `url` is `l` for a URL-driven switch (it becomes `heading`), undefined for
+* `setLocale`. Guards keep loading bundles while it waits (a link click
+* pushes the URL, then the lazy route's guard runs): in the old locale under
+* `setLocale`, in `l` under a URL-driven switch (`want`). Both are loaded
+* until nothing is left, or the new locale would flip without that route's
+* strings.
+*/
+function prepare(l, url) {
+	const n = ++switches;
+	const from = loc(page.locale);
+	const to = loc(l);
+	heading = url;
+	return loading = (async () => {
+		let keys = [...from.k, ...from.p.keys()];
+		do {
+			await load(l, keys);
+			if (n !== switches) return false;
+			keys = [
+				...from.k,
+				...from.p.keys(),
+				...to.p.keys()
+			].filter((k) => !to.k.has(k) && own(to.h, k));
+		} while (keys.length);
+		return true;
+	})();
+}
+/** Flips everything at once, once `l` is loaded. */
+function finish(l) {
+	heading = void 0;
+	flip(l);
+	persist(l);
+	changed(true);
+	for (const fn of subs) fn(l);
+}
+/**
+* Cancels the pending switch: its loads complete, but it never flips.
+* Guards that resolved in a URL-driven switch's locale let their routes
+* render (a guard redirected back, the router went elsewhere): what that
+* locale has and the page's lacks, which is what they loaded (a switch
+* first loads every key the page has), loads in the page's locale, and the
+* ids missed meanwhile re-render once it arrives.
+*/
+function cancel() {
+	if (heading) {
+		const d = loc(heading);
+		load(page.locale, [...d.k, ...d.p.keys()]).catch(noop);
+	}
+	switches++;
+	heading = void 0;
+}
+/**
+* `setLocale`: loads `l` for every key the page uses, flips, then puts `l`
+* into the URL through the navigator.
+*/
+async function switchTo(l) {
+	if (!S.locales.includes(l)) throw new RangeError("vi18n: unknown locale " + l);
+	const config = reg.config;
+	const url = (BUILD || browser()) && config.routing.url !== "no_prefix" && lists(location.pathname, "url");
+	if (config.routing.switch === "navigate" || url && !nav || ROUTES && url && away(l)) return leave(l);
+	const link = heading;
+	const kept = l === page.locale;
+	if (kept) {
+		cancel();
+		persist(l);
+	} else {
+		const p = prepare(l);
+		try {
+			if (!await p) return;
+		} catch (e) {
+			if (p !== loading) return;
+			if (e.skew) return leave(l);
+			throw e;
+		}
+		finish(l);
+	}
+	if (url && (link || (urlLocale(config, location.pathname) ?? (kept && l)) !== l)) nav(hrefIn(l));
+}
+/**
+* The page is going to a URL in locale `l`: it committed (`commit`), or a
+* link to it was clicked. Routers that load the route before they push its
+* URL (vue-router, Solid's) run its guards in between, so the click already
+* starts loading, and the commit flips. Routers that push first render the
+* route after the commit: its guard waits for the switch (`want`). A route
+* whose strings were loaded before (or preloaded on hover, as Solid's
+* router does) runs no guard, and stays in the old locale under the new
+* URL until the switch flips (INTERNALS §2.11.7). The watcher and the click
+* listener start at a client registration, so `reg` is set.
+*/
+function toward(l, commit) {
+	if (l === null) return;
+	if (l === page.locale) {
+		if (heading) cancel();
+	} else if (reg.config.routing.switch === "navigate") {
+		if (commit) go(location.href);
+	} else {
+		if (heading !== l) prepare(l, l);
+		loading.then((ok) => commit && ok && heading === l && finish(l), (e) => {
+			if (heading === l) {
+				cancel();
+				if (e.skew && named(location.pathname) === l) leave(l);
+			}
+			if (DEV) warnOnce("switching to " + l + " failed: " + e);
+		});
+	}
+}
+/** `setLocale` where a server registration may reach this engine: it throws there. */
+function setLocale(l) {
+	if (S.serverResolver || reg?.consumer === "server") return clientOnly(l);
+	return switchTo(l);
+}
+/** A same-document navigation committed: `location` is the new URL. */
+function onNavigate() {
+	if (BUILD || reg.mode === "build") try {
+		adoptLate();
+	} catch {}
+	const p = location.pathname;
+	if (p !== committed) toward(named(committed = p), true);
+}
+/**
+* A click on a same-origin link that a client router may follow (the
+* checks routers make), in the capture phase: before the router's handler,
+* whose route guards may start within the same task.
+*/
+function onClick(e) {
+	const a = e.composedPath().find((n) => n.href);
+	if (a && !(e.button || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) && (!a.target || a.target === "_self") && !a.hasAttribute("download") && a.origin === location.origin) toward(named(a.pathname));
+}
+/** The bridge's message key: `{ __vi18n: 1 }` from a booted worker, `{ __vi18n: Told }` to it. */
+const BRIDGE = "__vi18n";
+/** While set, the worker holds its incoming messages; they replay in order once it settles. */
+let gate;
+const held = [];
+/** Settles the first answer of the creating realm (set while the worker waits for it). */
+let answer;
+const dataOf = (e) => e.data?.[BRIDGE];
+/**
+* Holds the worker's messages until `p` and every load started meanwhile
+* settled, so handlers run with the locale's strings, as a chunk guard holds
+* a route; also messages that came while a module's top-level `await` (a
+* guard) kept its `onmessage` unset, which browsers would otherwise drop.
+* A later hold takes over and replays everything held.
+*/
+function hold(p) {
+	const g = gate = p.then(noop, noop).then(async () => {
+		while (inflight.size) await Promise.allSettled(inflight);
+	});
+	g.then(() => {
+		if (gate !== g) return;
+		gate = void 0;
+		setTimeout(() => {
+			if (gate) return;
+			for (const e of held.splice(0)) {
+				const copy = Object.assign(new MessageEvent("message", e), { vi18n: 1 });
+				dispatchEvent(copy);
+			}
+		});
+	});
+}
+/**
+* Switches the worker in place, what both the creating realm's flips and the
+* worker's own `setLocale` do: no URL, cookie or document to update.
+*/
+function inPlace(l) {
+	if (!S.locales.includes(l)) return Promise.reject(/* @__PURE__ */ new RangeError("vi18n: unknown locale " + l));
+	if (l === page.locale) {
+		cancel();
+		return resolved;
+	}
+	const p = prepare(l).then((ok) => {
+		if (ok) finish(l);
+	});
+	hold(p);
+	return p;
+}
+/** A message from the creating realm: its locale now, with what it knows of it. */
+function told(d) {
+	answer?.(d);
+	answer = void 0;
+	version ??= d.v;
+	const x = loc(d.l);
+	if (d.h && !x.r) {
+		x.h = d.h;
+		x.r = resolved;
+	}
+	inPlace(d.l).catch((e) => {
+		if (DEV) warnOnce("switching the worker to " + d.l + " failed: " + e);
+	});
+}
+/**
+* The engine's half of `register` in a module worker. A worker the bridge
+* created carries the creating realm's locale in its URL's fragment
+* (`#vi18n=<l>`), says hello once booted, and gets that realm's version and
+* manifest map back, then every switch. Without the fragment nothing created
+* it through the bridge, so nobody would answer, and it would hand an
+* unexpected message to the app's own handlers: it takes the browser's
+* languages and stays in that locale.
+*/
+function worker(r) {
+	const tag = /[#&]vi18n=([^&]*)/.exec(location.hash)?.[1];
+	let l = tag === void 0 ? "" : decodeURIComponent(tag);
+	const bridged = S.locales.includes(l);
+	if (!bridged) l = matchLocale(globalThis.navigator?.languages ?? [], r.config) ?? r.config.sourceLocale;
+	flip(l);
+	unwrap = wrapFetch(localeHeader);
+	S.setLocale = inPlace;
+	addEventListener("message", (e) => {
+		const d = dataOf(e);
+		if (d && typeof d === "object") {
+			e.stopImmediatePropagation();
+			told(d);
+		} else if (gate && !e.vi18n) {
+			e.stopImmediatePropagation();
+			held.push(e);
+		}
+	});
+	let reply = Promise.resolve(void 0);
+	if (bridged) {
+		reply = new Promise((settle) => answer = settle);
+		postMessage({ [BRIDGE]: 1 });
+	}
+	if (r.mode === "dev") {
+		const p = inFlight(devCatalog(l));
+		hold(Promise.all([p, reply]));
+		return p;
+	}
+	const d = loc(l);
+	const m = reply.then((t) => {
+		version ??= t?.v;
+		return t?.l === l && t.h ? t.h : acquire(l);
+	}).then((h) => d.h = h, (e) => {
+		d.r = void 0;
+		throw e;
+	});
+	d.r = m;
+	inFlight(m).catch(noop);
+	hold(reply);
+	return resolved;
+}
+/**
+* The creating side of the bridge: `virtual:vi18n/bridge` calls it in every
+* realm whose code constructs a worker (a page, or a worker that starts its
+* own). Each `new Worker(url)` gets the realm's locale as a URL fragment,
+* which leaves the request alone; a worker that answers with a hello is told
+* the version and map, then every locale this realm flips to. Workers that
+* never say hello (no vi18n in them, or `type: "classic"` scripts the
+* fragment does not reach) never hear from it.
+*/
+function bridge() {
+	const W = globalThis.Worker;
+	if (!created || !W || W.vi18n) return;
+	const workers = /* @__PURE__ */ new Set();
+	const tell = (w) => {
+		const told = {
+			l: page.locale,
+			v: version,
+			h: locs.get(page.locale)?.h
+		};
+		w.postMessage({ [BRIDGE]: told });
+	};
+	globalThis.Worker = class extends W {
+		static vi18n = 1;
+		constructor(url, options) {
+			const u = typeof url === "string" || url instanceof URL ? String(url) : null;
+			super(u === null ? url : u + (u.includes("#") ? "&" : "#") + "vi18n=" + encodeURIComponent(page.locale), options);
+			this.addEventListener("message", (e) => {
+				if (dataOf(e) === 1) {
+					e.stopImmediatePropagation();
+					workers.add(this);
+					tell(this);
+				}
+			});
+		}
+		terminate() {
+			workers.delete(this);
+			super.terminate();
+		}
+	};
+	subs.add(() => {
+		for (const w of workers) tell(w);
+	});
+}
+/**
+* `x-vi18n-locale` for same-origin requests, per `routing.propagate`: the
+* switch's locale once the URL names it, so the router's requests for the
+* new page carry it before the flip, else the page's (`sure`, §6 D108).
+*/
+const localeHeader = () => reg?.config.routing.propagate === "header" && (BUILD || !reg.test) ? sure() : null;
+/** Hooks into `register` and replaces the core's client stubs with this engine's methods. */
+function install() {
+	if (BUILD || browser()) unwrap = wrapFetch(localeHeader);
+	setEngine(boot);
+	const methods = {
+		need,
+		lazy: (importer, keys) => Promise.all([importer(), need(keys)]).then((r) => r[0]),
+		prefetch: (keys) => void want(keys).catch(noop),
+		async ready() {
+			if (BUILD || reg?.mode === "build") load(page.locale, ["base"]).catch(noop);
+			while (inflight.size) await Promise.allSettled(inflight);
+		},
+		setLocale: BUILD ? switchTo : setLocale,
+		missing(scope, key, reason) {
+			if (scope === page) {
+				missed.add(key);
+				if (reason === "unknown-id" && inflight.size) reason = "not-loaded";
+			}
+			report(key, scope.locale, reason);
+		}
+	};
+	if (INLINE) methods.add = (b) => merge(page.locale, [b]);
+	if (DEV) methods.replace = (l, catalog) => {
+		if (!S.locales.includes(l)) return;
+		setDev(l, catalog);
+		changed(false);
+	};
+	Object.assign(S, methods);
+	if (!BUILD && S.registration) boot(S.registration);
+}
+if (created) install();
+else if (DEV && S.need === S.ready) warnOnce("another copy of @menapo/vi18n without the client engine created the page state first, so this boot module's \"@menapo/vi18n/engine\" cannot install and t() renders no translations; dedupe the package");
+//#endregion
+export { bridge, inContext };