@embedpdf/plugin-i18n 3.0.0-next.14 → 3.0.0-next.15

package/dist/index.js

@@ -1,23 +1,764 @@
-import { t as I18nToken } from "./contract-D08iYq9-.js";
-import { definePlugin } from "@embedpdf/core";
-//#region src/translate.ts
+import { n as I18nToken, t as I18N_DEFAULTS } from "./contract-w0S-ipz5.js";
+import { PluginError, definePlugin, defineState, isPluginError, memo, toPluginError, toPluginErrorInfo } from "@embedpdf/core";
+//#region src/model.ts
+/** Nothing loaded yet: the controller seeds the state from the settings. */
+const initialI18nState = () => ({
+	locale: "",
+	locales: {},
+	loading: null,
+	waitingTranslations: {}
+});
+/**
+* The state the settings start with: their languages loaded, and their `locale` current. A start
+* language that is still to load shows `fallbackLocale` meanwhile, and `loading` names it, so the
+* loader fetches it once connected.
+*/
+function seedFromSettings(state, settings) {
+	const seeded = settings.locales.reduce(registerLocale, state);
+	const locale = settings.locale ?? settings.fallbackLocale;
+	if (seeded.locales[locale] || settings.loaders[locale] === void 0) return {
+		...seeded,
+		locale
+	};
+	return {
+		...seeded,
+		locale: settings.fallbackLocale,
+		loading: locale
+	};
+}
+/** Deep merge of two dictionaries: later leaves win, branches merge. */
+function mergeTranslations(base, patch) {
+	const merged = { ...base };
+	for (const [key, value] of Object.entries(patch)) {
+		const current = merged[key];
+		merged[key] = typeof value === "object" && typeof current === "object" ? mergeTranslations(current, value) : value;
+	}
+	return merged;
+}
+const hasDottedKey = (dictionary) => Object.entries(dictionary).some(([key, value]) => key.includes(".") || typeof value === "object" && hasDottedKey(value));
+/**
+* Dotted keys as branches, the shape `t()` walks: `{ 'review.reject': 'Afwijzen' }` is
+* `{ review: { reject: 'Afwijzen' } }`. Keys merge in order, so a later one wins. A dictionary
+* without a dotted key comes back as it is.
+*/
+function nestKeys(dictionary) {
+	if (!hasDottedKey(dictionary)) return dictionary;
+	let nested = {};
+	for (const [key, value] of Object.entries(dictionary)) {
+		const leaf = typeof value === "object" ? nestKeys(value) : value;
+		const branch = key.split(".").reduceRight((inner, part) => ({ [part]: inner }), leaf);
+		nested = mergeTranslations(nested, branch);
+	}
+	return nested;
+}
+const withNestedKeys = (locale) => {
+	const translations = nestKeys(locale.translations);
+	return translations === locale.translations ? locale : {
+		...locale,
+		translations
+	};
+};
+/**
+* Switch to a loaded language and end any load. A code that isn't loaded changes nothing: a
+* language in `loaders` becomes current through {@link startLocaleLoad}, {@link registerLocale}
+* and then this transition, which the loader drives.
+*/
+function setLocale(state, code) {
+	if (!state.locales[code]) return state;
+	if (state.locale === code && state.loading === null) return state;
+	return {
+		...state,
+		locale: code,
+		loading: null
+	};
+}
+/** Add a language, with any strings that were added to it before it loaded on top. */
+function registerLocale(state, locale) {
+	const pack = withNestedKeys(locale);
+	const waiting = state.waitingTranslations[locale.code];
+	if (!waiting) return {
+		...state,
+		locales: {
+			...state.locales,
+			[locale.code]: pack
+		}
+	};
+	const { [locale.code]: _merged, ...stillWaiting } = state.waitingTranslations;
+	return {
+		...state,
+		locales: {
+			...state.locales,
+			[locale.code]: {
+				...pack,
+				translations: mergeTranslations(pack.translations, waiting)
+			}
+		},
+		waitingTranslations: stillWaiting
+	};
+}
+function unregisterLocale(state, code) {
+	if (!state.locales[code]) return state;
+	const { [code]: _removed, ...locales } = state.locales;
+	return {
+		...state,
+		locales
+	};
+}
+/**
+* Merge strings into a language, later keys winning. For a language that isn't loaded yet (one in
+* `loaders`), the strings wait and merge in when it loads; the controller only lets codes with a
+* loader get here.
+*/
+function addTranslations(state, code, dictionary) {
+	const strings = nestKeys(dictionary);
+	const pack = state.locales[code];
+	if (!pack) {
+		const waiting = state.waitingTranslations[code] ?? {};
+		return {
+			...state,
+			waitingTranslations: {
+				...state.waitingTranslations,
+				[code]: mergeTranslations(waiting, strings)
+			}
+		};
+	}
+	return {
+		...state,
+		locales: {
+			...state.locales,
+			[code]: {
+				...pack,
+				translations: mergeTranslations(pack.translations, strings)
+			}
+		}
+	};
+}
+/** A language in `loaders` is wanted: the loader fetches whatever `loading` names. */
+function startLocaleLoad(state, code) {
+	return state.loading === code ? state : {
+		...state,
+		loading: code
+	};
+}
+/** A load ended without switching: it failed or was cancelled. Only the load still wanted ends. */
+function endLocaleLoad(state, code) {
+	return state.loading === code ? {
+		...state,
+		loading: null
+	} : state;
+}
+//#endregion
+//#region src/sync/loaders.ts
 /**
-* The pure lookup core — state in, string out. No platform access anywhere
-* (`Intl.PluralRules` is core ECMAScript, not DOM); this is the part that
-* ports to Rust verbatim.
+* The plugin's only side effect: fetching languages from `loaders`. Driven by
+* state: a load is `state.loading`, set by `setLocale` (a switch to a language
+* still to load) or by the seeded state (a start language still to load), so a
+* load asked for before `connect` ran is picked up here.
 */
-/** Walk a dotted path ('commands.zoom.in') through a dictionary tree. */
-function lookup(dict, key) {
-	if (!dict) return void 0;
-	let node = dict;
+function createLoaders(ctx, settings, settlers, onFailed) {
+	const load = (code) => {
+		const loader = settings.get().loaders[code];
+		if (!loader) {
+			ctx.state.update(endLocaleLoad, code);
+			return;
+		}
+		loader().then((locale) => {
+			ctx.state.update(registerLocale, locale);
+			if (ctx.state.get().loading === code) {
+				ctx.state.update(setLocale, locale.code);
+				settlers.settle(code, { ok: true });
+			}
+		}, (error) => {
+			ctx.state.update(endLocaleLoad, code);
+			onFailed(code, error);
+			settlers.settle(code, {
+				ok: false,
+				error: new PluginError("operation-failed", "i18n", `locale '${code}' failed to load`, { details: toPluginErrorInfo(toPluginError("i18n", error)) })
+			});
+		});
+	};
+	/** Fetch the language `loading` names now, and each one asked for after. */
+	const connect = () => {
+		const loadRequested = (code) => {
+			if (code) load(code);
+		};
+		loadRequested(ctx.state.get().loading);
+		ctx.watch(() => ctx.state.get().loading, loadRequested);
+	};
+	return { connect };
+}
+//#endregion
+//#region src/negotiate.ts
+/**
+* Pure locale negotiation over language tags (RFC 5646) — strings in, string
+* out. The plugin never reads the platform; the embedder feeds it whatever
+* request list its environment offers:
+*
+* ```ts
+* // browser shell:  negotiateLocale(['en', 'es', 'ar'], navigator.languages)
+* // server render:  negotiateLocale(codes, parseAcceptLanguage(header))
+* ```
+*
+* Matching, per requested code in preference order:
+*   1. exact match (case-insensitive):        `es-MX` → `es-MX`
+*   2. request narrowed to its language:      `en-GB` → `en`
+*   3. any available dialect of the language: `zh`    → `zh-Hans`
+*
+* Steps 2 and 3 match only within the script the language is written in, as
+* `Intl.Locale#maximize` gives it: `zh-TW` and `zh-HK` are Traditional
+* Chinese, so `zh-CN` (Simplified) isn't theirs, and they get no match until
+* a Traditional language is available. Where the platform can't tell a tag's
+* script, the language alone decides.
+*
+* Returns the matched code exactly as it appears in `available`, or null.
+*/
+/** The script a tag's language is written in (`zh-TW` → `Hant`, `zh` → `Hans`), or null. */
+function scriptOf(code) {
+	try {
+		return new Intl.Locale(code).maximize().script ?? null;
+	} catch {
+		return null;
+	}
+}
+/** Whether two tags are written in the same script, or one of them can't say. */
+function sameScript(left, right) {
+	const leftScript = scriptOf(left);
+	const rightScript = scriptOf(right);
+	return leftScript === null || rightScript === null || leftScript === rightScript;
+}
+function negotiateLocale(available, requested) {
+	const byCanonical = /* @__PURE__ */ new Map();
+	for (const code of available) {
+		const canonical = code.toLowerCase();
+		if (!byCanonical.has(canonical)) byCanonical.set(canonical, code);
+	}
+	const languageOf = (code) => code.toLowerCase().split("-")[0];
+	for (const wanted of requested) {
+		const exact = byCanonical.get(wanted.toLowerCase());
+		if (exact !== void 0) return exact;
+	}
+	for (const wanted of requested) {
+		const narrowed = byCanonical.get(languageOf(wanted));
+		if (narrowed !== void 0 && sameScript(wanted, narrowed)) return narrowed;
+	}
+	for (const wanted of requested) {
+		const language = languageOf(wanted);
+		for (const [canonical, original] of byCanonical) if (languageOf(canonical) === language && sameScript(wanted, original)) return original;
+	}
+	return null;
+}
+//#endregion
+//#region src/strings/index.ts
+const EMBEDPDF_STRINGS = {
+	en: { commands: {
+		zoom: {
+			in: "Zoom in",
+			out: "Zoom out",
+			fitWidth: "Fit width",
+			fitPage: "Fit page"
+		},
+		page: {
+			next: "Next page",
+			previous: "Previous page",
+			first: "First page",
+			last: "Last page"
+		},
+		view: {
+			rotateClockwise: "Rotate clockwise",
+			rotateCounterclockwise: "Rotate counterclockwise"
+		},
+		selection: { copy: "Copy" },
+		annotation: { delete: "Delete" },
+		document: {
+			download: "Download",
+			print: "Print"
+		},
+		tool: {
+			pointer: "Select",
+			pan: "Pan",
+			highlight: "Highlight",
+			underline: "Underline",
+			strikeout: "Strikethrough",
+			squiggly: "Squiggly underline",
+			"insert-text": "Insert text",
+			"replace-text": "Replace text",
+			ink: "Draw",
+			"ink-highlight": "Highlighter",
+			"free-text": "Text box",
+			"free-text-callout": "Callout",
+			note: "Note",
+			square: "Rectangle",
+			circle: "Ellipse",
+			line: "Line",
+			polygon: "Polygon",
+			polyline: "Polyline",
+			link: "Link",
+			stamp: "Stamp",
+			attachment: "Attach file",
+			redact: "Redact",
+			distance: "Distance",
+			perimeter: "Perimeter",
+			area: "Area",
+			calibrate: "Calibrate",
+			"form-fill": "Fill form",
+			"form-edit": "Edit form",
+			"form-text": "Text field",
+			"form-checkbox": "Checkbox",
+			"form-radio": "Radio button",
+			"form-combobox": "Dropdown",
+			"form-listbox": "List box",
+			"form-signature": "Signature field"
+		}
+	} },
+	nl: { commands: {
+		zoom: {
+			in: "Inzoomen",
+			out: "Uitzoomen",
+			fitWidth: "Paginabreedte",
+			fitPage: "Hele pagina"
+		},
+		page: {
+			next: "Volgende pagina",
+			previous: "Vorige pagina",
+			first: "Eerste pagina",
+			last: "Laatste pagina"
+		},
+		view: {
+			rotateClockwise: "Rechtsom draaien",
+			rotateCounterclockwise: "Linksom draaien"
+		},
+		selection: { copy: "Kopiëren" },
+		annotation: { delete: "Verwijderen" },
+		document: {
+			download: "Downloaden",
+			print: "Afdrukken"
+		},
+		tool: {
+			pointer: "Selecteren",
+			pan: "Verschuiven",
+			highlight: "Markeren",
+			underline: "Onderstrepen",
+			strikeout: "Doorhalen",
+			squiggly: "Golflijn",
+			"insert-text": "Tekst invoegen",
+			"replace-text": "Tekst vervangen",
+			ink: "Tekenen",
+			"ink-highlight": "Markeerstift",
+			"free-text": "Tekstvak",
+			"free-text-callout": "Toelichting",
+			note: "Notitie",
+			square: "Rechthoek",
+			circle: "Ellips",
+			line: "Lijn",
+			polygon: "Veelhoek",
+			polyline: "Polylijn",
+			link: "Koppeling",
+			stamp: "Stempel",
+			attachment: "Bestand bijvoegen",
+			redact: "Redigeren",
+			distance: "Afstand",
+			perimeter: "Omtrek",
+			area: "Oppervlakte",
+			calibrate: "Kalibreren",
+			"form-fill": "Formulier invullen",
+			"form-edit": "Formulier bewerken",
+			"form-text": "Tekstveld",
+			"form-checkbox": "Selectievakje",
+			"form-radio": "Keuzerondje",
+			"form-combobox": "Vervolgkeuzelijst",
+			"form-listbox": "Keuzelijst",
+			"form-signature": "Handtekeningveld"
+		}
+	} },
+	de: { commands: {
+		zoom: {
+			in: "Vergrößern",
+			out: "Verkleinern",
+			fitWidth: "Seitenbreite",
+			fitPage: "Ganze Seite"
+		},
+		page: {
+			next: "Nächste Seite",
+			previous: "Vorherige Seite",
+			first: "Erste Seite",
+			last: "Letzte Seite"
+		},
+		view: {
+			rotateClockwise: "Im Uhrzeigersinn drehen",
+			rotateCounterclockwise: "Gegen den Uhrzeigersinn drehen"
+		},
+		selection: { copy: "Kopieren" },
+		annotation: { delete: "Löschen" },
+		document: {
+			download: "Herunterladen",
+			print: "Drucken"
+		},
+		tool: {
+			pointer: "Auswählen",
+			pan: "Verschieben",
+			highlight: "Hervorheben",
+			underline: "Unterstreichen",
+			strikeout: "Durchstreichen",
+			squiggly: "Wellenlinie",
+			"insert-text": "Text einfügen",
+			"replace-text": "Text ersetzen",
+			ink: "Zeichnen",
+			"ink-highlight": "Textmarker",
+			"free-text": "Textkommentar",
+			"free-text-callout": "Legende",
+			note: "Notiz",
+			square: "Rechteck",
+			circle: "Ellipse",
+			line: "Linie",
+			polygon: "Polygon",
+			polyline: "Polylinie",
+			link: "Link",
+			stamp: "Stempel",
+			attachment: "Datei anhängen",
+			redact: "Schwärzen",
+			distance: "Abstand",
+			perimeter: "Umfang",
+			area: "Fläche",
+			calibrate: "Kalibrieren",
+			"form-fill": "Formular ausfüllen",
+			"form-edit": "Formular bearbeiten",
+			"form-text": "Textfeld",
+			"form-checkbox": "Kontrollkästchen",
+			"form-radio": "Optionsfeld",
+			"form-combobox": "Dropdown-Liste",
+			"form-listbox": "Listenfeld",
+			"form-signature": "Unterschriftsfeld"
+		}
+	} },
+	fr: { commands: {
+		zoom: {
+			in: "Zoom avant",
+			out: "Zoom arrière",
+			fitWidth: "Pleine largeur",
+			fitPage: "Page entière"
+		},
+		page: {
+			next: "Page suivante",
+			previous: "Page précédente",
+			first: "Première page",
+			last: "Dernière page"
+		},
+		view: {
+			rotateClockwise: "Rotation horaire",
+			rotateCounterclockwise: "Rotation antihoraire"
+		},
+		selection: { copy: "Copier" },
+		annotation: { delete: "Supprimer" },
+		document: {
+			download: "Télécharger",
+			print: "Imprimer"
+		},
+		tool: {
+			pointer: "Sélectionner",
+			pan: "Déplacer",
+			highlight: "Surligner",
+			underline: "Souligner",
+			strikeout: "Barrer",
+			squiggly: "Soulignement ondulé",
+			"insert-text": "Insérer du texte",
+			"replace-text": "Remplacer le texte",
+			ink: "Dessiner",
+			"ink-highlight": "Surligneur",
+			"free-text": "Zone de texte",
+			"free-text-callout": "Légende",
+			note: "Note",
+			square: "Rectangle",
+			circle: "Ellipse",
+			line: "Ligne",
+			polygon: "Polygone",
+			polyline: "Polyligne",
+			link: "Lien",
+			stamp: "Tampon",
+			attachment: "Joindre un fichier",
+			redact: "Biffer",
+			distance: "Distance",
+			perimeter: "Périmètre",
+			area: "Aire",
+			calibrate: "Étalonner",
+			"form-fill": "Remplir le formulaire",
+			"form-edit": "Modifier le formulaire",
+			"form-text": "Champ de texte",
+			"form-checkbox": "Case à cocher",
+			"form-radio": "Bouton radio",
+			"form-combobox": "Liste déroulante",
+			"form-listbox": "Zone de liste",
+			"form-signature": "Champ de signature"
+		}
+	} },
+	es: { commands: {
+		zoom: {
+			in: "Acercar",
+			out: "Alejar",
+			fitWidth: "Ajustar al ancho",
+			fitPage: "Ajustar a la página"
+		},
+		page: {
+			next: "Página siguiente",
+			previous: "Página anterior",
+			first: "Primera página",
+			last: "Última página"
+		},
+		view: {
+			rotateClockwise: "Girar a la derecha",
+			rotateCounterclockwise: "Girar a la izquierda"
+		},
+		selection: { copy: "Copiar" },
+		annotation: { delete: "Eliminar" },
+		document: {
+			download: "Descargar",
+			print: "Imprimir"
+		},
+		tool: {
+			pointer: "Seleccionar",
+			pan: "Desplazar",
+			highlight: "Resaltar",
+			underline: "Subrayar",
+			strikeout: "Tachar",
+			squiggly: "Subrayado ondulado",
+			"insert-text": "Insertar texto",
+			"replace-text": "Reemplazar texto",
+			ink: "Dibujar",
+			"ink-highlight": "Marcador",
+			"free-text": "Cuadro de texto",
+			"free-text-callout": "Llamada",
+			note: "Nota",
+			square: "Rectángulo",
+			circle: "Elipse",
+			line: "Línea",
+			polygon: "Polígono",
+			polyline: "Polilínea",
+			link: "Enlace",
+			stamp: "Sello",
+			attachment: "Adjuntar archivo",
+			redact: "Censurar",
+			distance: "Distancia",
+			perimeter: "Perímetro",
+			area: "Área",
+			calibrate: "Calibrar",
+			"form-fill": "Rellenar formulario",
+			"form-edit": "Editar formulario",
+			"form-text": "Campo de texto",
+			"form-checkbox": "Casilla de verificación",
+			"form-radio": "Botón de opción",
+			"form-combobox": "Lista desplegable",
+			"form-listbox": "Cuadro de lista",
+			"form-signature": "Campo de firma"
+		}
+	} },
+	"zh-CN": { commands: {
+		zoom: {
+			in: "放大",
+			out: "缩小",
+			fitWidth: "适合宽度",
+			fitPage: "适合页面"
+		},
+		page: {
+			next: "下一页",
+			previous: "上一页",
+			first: "第一页",
+			last: "最后一页"
+		},
+		view: {
+			rotateClockwise: "顺时针旋转",
+			rotateCounterclockwise: "逆时针旋转"
+		},
+		selection: { copy: "复制" },
+		annotation: { delete: "删除" },
+		document: {
+			download: "下载",
+			print: "打印"
+		},
+		tool: {
+			pointer: "选择",
+			pan: "平移",
+			highlight: "高亮",
+			underline: "下划线",
+			strikeout: "删除线",
+			squiggly: "波浪线",
+			"insert-text": "插入文本",
+			"replace-text": "替换文本",
+			ink: "绘图",
+			"ink-highlight": "荧光笔",
+			"free-text": "文本框",
+			"free-text-callout": "标注",
+			note: "便笺",
+			square: "矩形",
+			circle: "椭圆",
+			line: "直线",
+			polygon: "多边形",
+			polyline: "折线",
+			link: "链接",
+			stamp: "图章",
+			attachment: "附加文件",
+			redact: "涂黑",
+			distance: "距离",
+			perimeter: "周长",
+			area: "面积",
+			calibrate: "校准",
+			"form-fill": "填写表单",
+			"form-edit": "编辑表单",
+			"form-text": "文本字段",
+			"form-checkbox": "复选框",
+			"form-radio": "单选按钮",
+			"form-combobox": "下拉列表",
+			"form-listbox": "列表框",
+			"form-signature": "签名字段"
+		}
+	} },
+	sv: { commands: {
+		zoom: {
+			in: "Zooma in",
+			out: "Zooma ut",
+			fitWidth: "Anpassa till bredd",
+			fitPage: "Anpassa till sida"
+		},
+		page: {
+			next: "Nästa sida",
+			previous: "Föregående sida",
+			first: "Första sidan",
+			last: "Sista sidan"
+		},
+		view: {
+			rotateClockwise: "Rotera medurs",
+			rotateCounterclockwise: "Rotera moturs"
+		},
+		selection: { copy: "Kopiera" },
+		annotation: { delete: "Ta bort" },
+		document: {
+			download: "Ladda ned",
+			print: "Skriv ut"
+		},
+		tool: {
+			pointer: "Välj",
+			pan: "Panorera",
+			highlight: "Markera",
+			underline: "Stryk under",
+			strikeout: "Stryk över",
+			squiggly: "Vågig understrykning",
+			"insert-text": "Infoga text",
+			"replace-text": "Ersätt text",
+			ink: "Rita",
+			"ink-highlight": "Överstrykningspenna",
+			"free-text": "Textruta",
+			"free-text-callout": "Pratbubbla",
+			note: "Anteckning",
+			square: "Rektangel",
+			circle: "Ellips",
+			line: "Linje",
+			polygon: "Polygon",
+			polyline: "Polylinje",
+			link: "Länk",
+			stamp: "Stämpel",
+			attachment: "Bifoga fil",
+			redact: "Maskera",
+			distance: "Avstånd",
+			perimeter: "Omkrets",
+			area: "Area",
+			calibrate: "Kalibrera",
+			"form-fill": "Fyll i formulär",
+			"form-edit": "Redigera formulär",
+			"form-text": "Textfält",
+			"form-checkbox": "Kryssruta",
+			"form-radio": "Alternativknapp",
+			"form-combobox": "Rullgardinsmeny",
+			"form-listbox": "Listruta",
+			"form-signature": "Signaturfält"
+		}
+	} },
+	ja: { commands: {
+		zoom: {
+			in: "拡大",
+			out: "縮小",
+			fitWidth: "幅に合わせる",
+			fitPage: "ページ全体を表示"
+		},
+		page: {
+			next: "次のページ",
+			previous: "前のページ",
+			first: "最初のページ",
+			last: "最後のページ"
+		},
+		view: {
+			rotateClockwise: "右に回転",
+			rotateCounterclockwise: "左に回転"
+		},
+		selection: { copy: "コピー" },
+		annotation: { delete: "削除" },
+		document: {
+			download: "ダウンロード",
+			print: "印刷"
+		},
+		tool: {
+			pointer: "選択",
+			pan: "パン",
+			highlight: "ハイライト",
+			underline: "下線",
+			strikeout: "取り消し線",
+			squiggly: "波線",
+			"insert-text": "テキストを挿入",
+			"replace-text": "テキストを置換",
+			ink: "描画",
+			"ink-highlight": "蛍光ペン",
+			"free-text": "テキストボックス",
+			"free-text-callout": "引き出し線",
+			note: "ノート",
+			square: "長方形",
+			circle: "楕円",
+			line: "線",
+			polygon: "多角形",
+			polyline: "折れ線",
+			link: "リンク",
+			stamp: "スタンプ",
+			attachment: "ファイルを添付",
+			redact: "墨消し",
+			distance: "距離",
+			perimeter: "周囲長",
+			area: "面積",
+			calibrate: "校正",
+			"form-fill": "フォームに入力",
+			"form-edit": "フォームを編集",
+			"form-text": "テキストフィールド",
+			"form-checkbox": "チェックボックス",
+			"form-radio": "ラジオボタン",
+			"form-combobox": "ドロップダウン",
+			"form-listbox": "リストボックス",
+			"form-signature": "署名フィールド"
+		}
+	} }
+};
+const CODES = Object.keys(EMBEDPDF_STRINGS);
+/** Which of EmbedPDF's languages each code reads, decided once per code. */
+const languageOf = /* @__PURE__ */ new Map();
+/**
+* EmbedPDF's strings for a language code, matched as `negotiateLocale` matches: `nl-BE` reads
+* Dutch and `zh` Simplified Chinese. `undefined` for a language EmbedPDF has no strings in.
+*/
+function embedpdfStringsFor(code) {
+	let language = languageOf.get(code);
+	if (language === void 0) {
+		language = negotiateLocale(CODES, [code]);
+		languageOf.set(code, language);
+	}
+	return language === null ? void 0 : EMBEDPDF_STRINGS[language];
+}
+//#endregion
+//#region src/translate.ts
+/** Walk a dotted path (`'commands.zoom.in'`) through a dictionary. */
+function lookup(dictionary, key) {
+	if (!dictionary) return void 0;
+	let node = dictionary;
 	for (const part of key.split(".")) {
 		if (node === void 0 || typeof node === "string") return void 0;
 		node = node[part];
 	}
 	return node;
 }
-/** CLDR plural category for a count, with a safe fallback when the runtime
-*  lacks ICU data for the locale. */
+/** The language's plural form for a count; `'one'` or `'other'` when the runtime has no rules for it. */
 function pluralCategory(locale, count) {
 	try {
 		return new Intl.PluralRules(locale).select(count);
@@ -25,7 +766,7 @@ function pluralCategory(locale, count) {
 		return count === 1 ? "one" : "other";
 	}
 }
-/** A leaf hit is a string; a branch object needs a plural pick via `count`. */
+/** A string is the answer; a branch needs a plural form, picked by `params.count`. */
 function resolveNode(node, locale, params) {
 	if (typeof node === "string") return node;
 	if (node !== void 0 && typeof params?.count === "number") {
@@ -33,18 +774,22 @@ function resolveNode(node, locale, params) {
 		if (typeof branch === "string") return branch;
 	}
 }
-/** Replace `{slot}` markers; unknown slots stay verbatim (visible in QA). */
+/** Fill in `{name}` slots; a slot without a value stays as it is, so it shows while testing. */
 function interpolate(text, params) {
 	if (!params) return text;
 	return text.replace(/\{(\w+)\}/g, (match, slot) => params[slot] !== void 0 ? String(params[slot]) : match);
 }
+/** A key in one language: the app's string, then EmbedPDF's own. */
+const stringIn = (sources, code, key, params) => resolveNode(lookup(sources.locales[code]?.translations, key), code, params) ?? resolveNode(lookup(embedpdfStringsFor(code), key), code, params);
 /**
-* Resolve a key against the state: current locale → fallback locale →
-* `options.fallback` (interpolated too) → the key itself.
+* A key's string: in the current language (the key, then `options.fallbackKey`), then the same in
+* the fallback language, then `options.fallback` (with its slots filled too), then the key itself.
 */
-function translate(state, key, options) {
-	const { locale, fallbackLocale, locales } = state;
-	const text = resolveNode(lookup(locales[locale]?.translations, key), locale, options?.params) ?? resolveNode(lookup(locales[fallbackLocale]?.translations, key), fallbackLocale, options?.params);
+function translate(sources, key, options) {
+	const params = options?.params;
+	const fallbackKey = options?.fallbackKey;
+	const inLanguage = (code) => stringIn(sources, code, key, params) ?? (fallbackKey === void 0 ? void 0 : stringIn(sources, code, fallbackKey, params));
+	const text = inLanguage(sources.locale) ?? inLanguage(sources.fallbackLocale);
 	if (text !== void 0) return {
 		text: interpolate(text, options?.params),
 		found: true
@@ -59,203 +804,192 @@ function translate(state, key, options) {
 	};
 }
 //#endregion
-//#region src/capability.ts
+//#region src/controller.ts
 /**
-* The i18n capability — selectors (pure reads over state) + intents (the only
-* writers). Built synchronously in `createKernel()`, so `t()` works before the
-* engine exists — including inside the viewer shell's loading UI.
+* The i18n controller: reads over the state, the language verbs, the
+* `onLocaleChanged` derivation, and the loader wired at `connect`. Built
+* synchronously in `createKernel()`, so `t()` works before the engine exists.
 */
-function createI18nCapability(ctx, config) {
+const unknownLocale = (code) => new PluginError("not-found", "i18n", `unknown locale '${code}': not loaded and not in loaders`);
+function createI18nController(ctx) {
+	const settings = ctx.settings();
+	const localeChanged = ctx.events.source();
+	const localeLoadFailed = ctx.events.source();
+	const state = () => ctx.state.get();
+	ctx.state.update(seedFromSettings, settings.get());
+	let announced = state().locale;
+	ctx.state.onChange(({ next }) => {
+		if (next.loading !== null || next.locale === announced) return;
+		const previousLocale = announced;
+		announced = next.locale;
+		localeChanged.emit({
+			locale: next.locale,
+			previousLocale
+		});
+	});
+	const sources = () => ({
+		locale: state().locale,
+		fallbackLocale: settings.get().fallbackLocale,
+		locales: state().locales
+	});
 	const warned = /* @__PURE__ */ new Set();
-	const warnOnce = (id, message) => {
-		if (warned.has(id)) return;
-		warned.add(id);
-		console.warn(message);
+	const translateKey = (key, options) => {
+		const result = translate(sources(), key, options);
+		const missing = options?.fallbackKey === void 0 ? `"${key}"` : `"${key}" or "${options.fallbackKey}"`;
+		if (!result.found && options?.fallback === void 0 && !warned.has(missing)) {
+			warned.add(missing);
+			console.warn(`[i18n] missing translation ${missing} (locale: ${state().locale})`);
+		}
+		return result.text;
 	};
-	return {
-		t: (key, options) => {
-			const result = translate(ctx.getState(), key, options);
-			if (!result.found && options?.fallback === void 0) warnOnce(`key:${key}`, `[i18n] missing translation "${key}" (locale: ${ctx.getState().locale})`);
-			return result.text;
-		},
-		locale: () => ctx.getState().locale,
-		dir: () => {
-			const { locales, locale } = ctx.getState();
-			return locales[locale]?.dir ?? "ltr";
-		},
-		locales: () => {
-			const { locales } = ctx.getState();
-			const known = Object.values(locales).map((locale) => ({
-				code: locale.code,
-				name: locale.name,
-				dir: locale.dir ?? "ltr",
-				loaded: true
-			}));
-			for (const code of Object.keys(config.loaders ?? {})) if (!locales[code]) known.push({
-				code,
-				name: code,
-				dir: "ltr",
-				loaded: false
-			});
-			return known;
-		},
-		loading: () => ctx.getState().loading,
-		setLocale: (code) => {
-			if (ctx.getState().locales[code]) ctx.dispatch({
-				type: "I18N/SET_LOCALE",
-				locale: code
-			});
-			else if (config.loaders?.[code]) ctx.dispatch({
-				type: "I18N/LOAD_STARTED",
-				locale: code
+	/** A new translate function only when the strings it can return may differ. */
+	const getTranslator = memo(() => [
+		state().locale,
+		state().locales,
+		settings.get().fallbackLocale
+	], (_locale, _locales, _fallbackLocale) => (key, options) => translateKey(key, options));
+	/** The languages a picker shows, rebuilt only when the languages or the loaders change. */
+	const listLocales = memo(() => [state().locales, settings.get().loaders], (locales, loaders) => {
+		const known = Object.values(locales).map((locale) => ({
+			code: locale.code,
+			name: locale.name,
+			direction: locale.direction ?? "ltr",
+			loaded: true
+		}));
+		for (const code of Object.keys(loaders)) if (!locales[code]) known.push({
+			code,
+			name: code,
+			direction: "ltr",
+			loaded: false
+		});
+		return known;
+	});
+	/** The caller waiting for a language to load; a newer switch replaces it. */
+	const pending = /* @__PURE__ */ new Map();
+	const settle = (code, outcome) => {
+		const waiter = pending.get(code);
+		if (!waiter) return;
+		pending.delete(code);
+		if (outcome.ok) waiter.resolve();
+		else waiter.reject(outcome.error);
+	};
+	const supersede = () => {
+		for (const [code, waiter] of pending) {
+			pending.delete(code);
+			waiter.reject(new PluginError("operation-cancelled", "i18n", `switching to '${code}' was replaced`));
+		}
+	};
+	const loaders = createLoaders(ctx, settings, { settle }, (locale, error) => localeLoadFailed.emit({
+		locale,
+		error: toPluginErrorInfo(toPluginError("i18n", error))
+	}));
+	const setLocale$1 = (code, options = {}) => {
+		const { signal } = options;
+		if (signal?.aborted) return Promise.reject(new PluginError("operation-cancelled", "i18n", "operation cancelled"));
+		if (state().locales[code]) {
+			supersede();
+			ctx.state.update(setLocale, code);
+			return Promise.resolve();
+		}
+		if (!settings.get().loaders[code]) return Promise.reject(unknownLocale(code));
+		supersede();
+		const loaded = new Promise((resolve, reject) => {
+			pending.set(code, {
+				resolve,
+				reject
 			});
-			else warnOnce(`locale:${code}`, `[i18n] unknown locale "${code}" — not registered and no loader configured`);
-		},
-		registerLocale: (locale) => ctx.dispatch({
-			type: "I18N/REGISTER_LOCALE",
-			locale
-		})
+			ctx.state.update(startLocaleLoad, code);
+		});
+		signal?.addEventListener("abort", () => {
+			if (!pending.delete(code)) return;
+			ctx.state.update(endLocaleLoad, code);
+		}, { once: true });
+		return ctx.cancellable(signal, loaded);
 	};
-}
-//#endregion
-//#region src/effects.ts
-/**
-* The plugin's ONE side-effect: fetching lazy locale packs. State-driven — a
-* load is `state.loading`, set by the capability (a switch to a lazy pack) or
-* by the initial state (a lazy startup locale), so a load requested before
-* effects ran is picked up here and nothing is lost to boot ordering.
-*/
-function registerI18nEffects(config) {
-	return (ctx) => {
-		const load = (code) => {
-			const loader = config.loaders?.[code];
-			if (!loader) return;
-			loader().then((locale) => {
-				ctx.dispatch({
-					type: "I18N/REGISTER_LOCALE",
-					locale
-				});
-				if (ctx.getState().loading === code) ctx.dispatch({
-					type: "I18N/SET_LOCALE",
-					locale: locale.code
+	/** Follow a settings change: new languages register, and a new `locale` becomes current. */
+	const followSettings = () => {
+		let previous = settings.get();
+		ctx.listen(settings.api.onSettingsChanged, ({ settings: next, changed }) => {
+			if (changed.includes("locales")) {
+				for (const locale of previous.locales) if (!next.locales.some((other) => other.code === locale.code)) ctx.state.update(unregisterLocale, locale.code);
+				for (const locale of next.locales) if (!previous.locales.includes(locale)) ctx.state.update(registerLocale, locale);
+			}
+			if (changed.includes("locale")) {
+				const code = next.locale ?? next.fallbackLocale;
+				setLocale$1(code).catch((error) => {
+					if (isPluginError(error, "not-found")) console.warn(`[i18n] ${error.message}`);
 				});
-			}, () => ctx.dispatch({
-				type: "I18N/LOAD_FAILED",
-				locale: code
-			}));
-		};
-		const pending = ctx.getState().loading;
-		if (pending) load(pending);
-		ctx.watch(() => ctx.getState().loading, (code) => {
-			if (code) load(code);
+			}
+			previous = next;
 		});
 	};
-}
-//#endregion
-//#region src/reducer.ts
-/**
-* Pure and serializable — locale packs are data, so they live HERE, not in a
-* side-table. One source of truth: `t()` is a pure function of this state and
-* reactivity rides the kernel's one change stream (no emitters).
-*/
-function initialI18nState(config) {
-	const fallbackLocale = config.fallbackLocale ?? "en";
-	const locales = {};
-	for (const locale of config.locales ?? []) locales[locale.code] = locale;
-	const locale = config.locale ?? fallbackLocale;
 	return {
-		locale,
-		fallbackLocale,
-		locales,
-		loading: !locales[locale] && config.loaders?.[locale] !== void 0 ? locale : null
+		api: {
+			...settings.api,
+			t: translateKey,
+			getTranslator,
+			hasKey: (key) => translate(sources(), key).found,
+			getLocale: () => state().locale,
+			getDirection: () => state().locales[state().locale]?.direction ?? "ltr",
+			listLocales,
+			getLoadingLocale: () => state().loading,
+			setLocale: setLocale$1,
+			registerLocale: (locale) => {
+				ctx.state.update(registerLocale, locale);
+				return () => ctx.state.update(unregisterLocale, locale.code);
+			},
+			addTranslations: (code, translations) => {
+				if (!state().locales[code] && !settings.get().loaders[code]) throw unknownLocale(code);
+				ctx.state.update(addTranslations, code, translations);
+			},
+			onLocaleChanged: localeChanged.on,
+			onLocaleLoadFailed: localeLoadFailed.on
+		},
+		connect() {
+			loaders.connect();
+			followSettings();
+		}
 	};
 }
-function i18nReducer(state, action) {
-	switch (action.type) {
-		case "I18N/SET_LOCALE":
-			if (!state.locales[action.locale]) return state;
-			if (state.locale === action.locale && state.loading === null) return state;
-			return {
-				...state,
-				locale: action.locale,
-				loading: null
-			};
-		case "I18N/REGISTER_LOCALE": return {
-			...state,
-			locales: {
-				...state.locales,
-				[action.locale.code]: action.locale
-			}
-		};
-		case "I18N/LOAD_STARTED": return state.loading === action.locale ? state : {
-			...state,
-			loading: action.locale
-		};
-		case "I18N/LOAD_FAILED": return state.loading === action.locale ? {
-			...state,
-			loading: null
-		} : state;
-		default: return state;
-	}
-}
 //#endregion
 //#region src/i18n.plugin.ts
 /**
-* The i18n plugin: workspace-scoped (locale is a workspace concern) with NO
-* dependencies — engine-free, DOM-free. Its capability is built synchronously
-* in `createKernel()`, so the shell translates from the first frame, while
-* the engine is still booting.
+* Translations and the current language. Workspace-scoped, with no dependencies and no engine
+* calls: the capability exists from `createKernel()`, so the viewer translates while the engine
+* is still loading. `config` is the settings the app registers, over {@link I18N_DEFAULTS}.
 */
-const i18nPlugin = (config = {}) => definePlugin({
+const i18nPlugin = (config) => definePlugin({
 	id: "i18n",
 	scope: "workspace",
 	token: I18nToken,
-	initialState: () => initialI18nState(config),
-	reduce: i18nReducer,
-	capability: (ctx) => createI18nCapability(ctx, config),
-	effects: registerI18nEffects(config)
+	state: initialI18nState,
+	settings: {
+		defaults: I18N_DEFAULTS,
+		registered: config
+	},
+	create: createI18nController
 });
 //#endregion
-//#region src/negotiate.ts
+//#region src/state.ts
 /**
-* Pure BCP-47 locale negotiation — strings in, string out. The plugin never
-* reads the platform; the EMBEDDER feeds it whatever request list its
-* environment offers:
-*
-* ```ts
-* // browser shell:  negotiateLocale(['en', 'es', 'ar'], navigator.languages)
-* // server render:  negotiateLocale(codes, parseAcceptLanguage(header))
-* ```
-*
-* Matching, per requested code in preference order:
-*   1. exact match (case-insensitive):        'es-MX' → 'es-MX'
-*   2. request narrowed to its language:      'en-GB' → 'en'
-*   3. any available dialect of the language: 'zh'    → 'zh-Hans'
-*
-* Returns the matched code exactly as it appears in `available`, or null.
+* The translations page's State table as code: what `useI18nState()` returns,
+* and the same fields in every other framework.
 */
-function negotiateLocale(available, requested) {
-	const byCanon = /* @__PURE__ */ new Map();
-	for (const code of available) {
-		const canon = code.toLowerCase();
-		if (!byCanon.has(canon)) byCanon.set(canon, code);
-	}
-	const languageOf = (code) => code.toLowerCase().split("-")[0];
-	for (const want of requested) {
-		const exact = byCanon.get(want.toLowerCase());
-		if (exact !== void 0) return exact;
+const i18nState = defineState(I18nToken, {
+	read: (i18n) => ({
+		locale: i18n.getLocale(),
+		direction: i18n.getDirection(),
+		locales: i18n.listLocales(),
+		loading: i18n.getLoadingLocale()
+	}),
+	empty: {
+		locale: "en",
+		direction: "ltr",
+		locales: [],
+		loading: null
 	}
-	for (const want of requested) {
-		const narrowed = byCanon.get(languageOf(want));
-		if (narrowed !== void 0) return narrowed;
-	}
-	for (const want of requested) {
-		const language = languageOf(want);
-		for (const [canon, original] of byCanon) if (languageOf(canon) === language) return original;
-	}
-	return null;
-}
+});
 //#endregion
-export { I18nToken, i18nPlugin, interpolate, negotiateLocale, translate };
+export { I18N_DEFAULTS, I18nToken, i18nPlugin, i18nState, negotiateLocale };
 
 //# sourceMappingURL=index.js.map