@prosopo/locale 3.9.0 → 3.10.0

package/dist/cjs/direction.cjs

@@ -1,19 +1,34 @@
 //#region src/direction.ts
-var RTL_LANGUAGES = /* @__PURE__ */ new Set([
-	"ar",
-	"ckb",
-	"dv",
-	"fa",
-	"he",
-	"ps",
-	"sd",
-	"ug",
-	"ur",
-	"yi"
-]);
-var getLanguageDirection = (language) => {
-	const primary = language.split(/[-_]/)[0]?.toLowerCase() ?? "";
-	return RTL_LANGUAGES.has(primary) ? "rtl" : "ltr";
+var words = (list) => new Set(list.split(" "));
+var RTL_SCRIPTS = words("adlm arab armi avst chrs cprt elym gara hatr hebr hung khar lydi mand mani mend merc mero narb nbat nkoo orkh ougr palm phli phlp phnx prti rohg samr sarb sidt sogd sogo syrc thaa yezi");
+var RTL_LANGUAGES = words("aao abh abv acm acq acw acx adf ae aeb aec aee aeq afb aib aii aij aiq ajp ajt aju amw apc apd ar ara arb arc arq ars ary arz ask atn auj auz avd ave avl ayh ayl ayn ayp azb bal bcc bdz bej bft bgn bgp bhe bhm bhn bjf bjm bqi brh brk bsh bsk chg cja ckb cld clh czk dcc def deh dgl div dmk dml drw dv ecy esh fa fas fay faz fia fub gbz ggg gha ghr gig gjk gju glh glk grr gwc gwf gwt gzi hac haz hbo he heb hkh hnd hno hoh hrt hrz hss huy isk itk iw jad jat jbe jbn jdg ji jnd jog jpa jpr jrb jye kas kbu kby kcy kfm khw klj kmz kqd ks ktl kvx kxp kzh lad lah lhs lki lrc lrk lrl lsa lsd lss luv luz mby mde mey mfa mfi mhj mid mki mnj mve mvy myz mzb mzn nli nlm nqo ntz nyq oar obm odk oru ota otk oui pal pbt pbu per pes pgd phl phn phr phv plk pmu pnb prc prd prs prx ps psh psi pst pus qxq rdb rhg rmt sam sbn scl sd sdb sdf sdg sdh sds sgl sgr sgy shd shm shu shv siy siz skr smp smy snd sog sqo sqt srh srz ssh sts swb syc syn syr tjo tks tmr tnf tov tra trg trm trw ug uig ur urd ush uzs vaf vgr vmh wbk wlo wne wni wsv xco xhe xka xkc xkj xkp xld xly xmn xmr xna xpr xsa xsd xvi ydd ydg yhd yi yid yih yud zba zdj zrp zum");
+var RTL_LANGUAGE_REGIONS = words("az-iq az-ir ha-cm ha-sd kk-af kk-cn kk-ir kk-mn ku-iq ku-ir ku-lb ky-cn ms-cc pa-pk tg-pk uz-af");
+var isRtlByIntl = (tag) => {
+	try {
+		const locale = new Intl.Locale(tag);
+		return (typeof locale.getTextInfo === "function" ? locale.getTextInfo() : locale.textInfo)?.direction === "rtl";
+	} catch {
+		return false;
+	}
 };
+var SCRIPT_SUBTAG = /^[a-z]{4}$/;
+var REGION_SUBTAG = /^([a-z]{2}|[0-9]{3})$/;
+var isRtlByList = (tag) => {
+	const [language = "", ...subtags] = tag.toLowerCase().split(/[-_]/);
+	const extensionStart = subtags.findIndex((subtag) => subtag.length === 1);
+	const own = extensionStart === -1 ? subtags : subtags.slice(0, extensionStart);
+	const script = own.find((subtag) => SCRIPT_SUBTAG.test(subtag));
+	if (script) return RTL_SCRIPTS.has(script);
+	const region = own.find((subtag) => REGION_SUBTAG.test(subtag));
+	return RTL_LANGUAGES.has(language) || region !== void 0 && RTL_LANGUAGE_REGIONS.has(`${language}-${region}`);
+};
+/**
+* The direction a BCP 47 tag is written in. Right to left if our CLDR lists
+* say so or the browser's Intl does: the lists give every browser the same
+* answer for the languages they know, and Intl covers languages CLDR adds
+* after them. An explicit script wins over the language and region (`pa-Arab`
+* is rtl, `az-Latn-IR` ltr).
+*/
+var getLanguageDirection = (language) => isRtlByList(language) || isRtlByIntl(language) ? "rtl" : "ltr";
 //#endregion
 exports.getLanguageDirection = getLanguageDirection;

package/dist/cjs/errorMessage.cjs

@@ -4,11 +4,12 @@ const require_translationKey = require("./translationKey.cjs");
 * The provider translates error messages into the request's Accept-Language,
 * which is the browser's language rather than the widget's. Re-translating the
 * error key on the client shows the error in the language the widget renders
-* in. Free text and keys the catalogue doesn't have keep the server's message.
+* in. Free text and keys outside the widget namespace (which the browser has no
+* text for) keep the server's message.
 */
 var localiseErrorMessage = (i18n, error) => {
 	const { key, message } = error;
-	if (!key || !require_translationKey.isTranslationKey(key) || !i18n?.isInitialized) return message;
+	if (!key || !require_translationKey.isWidgetTranslationKey(key) || !i18n?.isInitialized) return message;
 	return i18n.t(key, { defaultValue: message });
 };
 //#endregion

package/dist/cjs/i18SharedOptions.cjs

@@ -2,7 +2,6 @@ const require_translations = require("./translations.cjs");
 var i18nSharedOptions = {
 	debug: require("./process.cjs").getProcess()?.env?.PROSOPO_LOG_LEVEL === "debug",
 	fallbackLng: require_translations.Languages.english,
-	namespace: "translation",
 	supportedLngs: require_translations.LanguageCodes,
 	nonExplicitSupportedLngs: false
 };

package/dist/cjs/i18nBackend.cjs

@@ -1,36 +1,48 @@
 const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
 const require_util = require("./util.cjs");
+const require_translationKey = require("./translationKey.cjs");
 const require_i18SharedOptions = require("./i18SharedOptions.cjs");
+const require_requestLanguageDetector = require("./requestLanguageDetector.cjs");
 let i18next = require("i18next");
 i18next = require_runtime.__toESM(i18next, 1);
-let i18next_http_middleware = require("i18next-http-middleware");
+let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_runtime.__toESM(node_path, 1);
+let node_url = require("node:url");
 let i18next_fs_backend_cjs = require("i18next-fs-backend/cjs");
 i18next_fs_backend_cjs = require_runtime.__toESM(i18next_fs_backend_cjs, 1);
 //#region src/i18nBackend.ts
-var loadPath = `${node_path.default.dirname(require("url").pathToFileURL(__filename).href)}/locales/{{lng}}/{{ns}}.json`.replace("file://", "");
+var localesDirectory = (moduleDirectory, exists = node_fs.existsSync) => {
+	const beside = node_path.default.join(moduleDirectory, "locales");
+	const above = node_path.default.join(moduleDirectory, "..", "locales");
+	const hasCatalogues = (directory) => exists(node_path.default.join(directory, "en", `${require_translationKey.NAMESPACES.server}.json`));
+	return !hasCatalogues(beside) && hasCatalogues(above) ? above : beside;
+};
+var loadPath = node_path.default.join(localesDirectory(node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href))), "{{lng}}", "{{ns}}.json");
+var isBackendClass = (value) => typeof value === "function" && "type" in value && value.type === "backend";
+var fsBackend = (loaded = i18next_fs_backend_cjs.default) => {
+	if (!isBackendClass(loaded)) throw new Error("i18next-fs-backend/cjs did not export a backend class");
+	return loaded;
+};
 function initializeI18n(i18nLoadedCallback) {
-	if (!i18next.default.isInitialized && require_util.isServerSide()) {
-		const lngDetector = new i18next_http_middleware.LanguageDetector(null, { order: [
-			"header",
-			"query",
-			"cookie"
-		] });
-		i18next.default.use(i18next_fs_backend_cjs.default).use(lngDetector).init({
-			...require_i18SharedOptions.i18nSharedOptions,
-			ns: ["translation"],
-			backend: { loadPath }
-		});
-		let notified = false;
-		i18next.default.on("loaded", () => {
-			if (notified) return;
-			notified = true;
-			i18nLoadedCallback?.(i18next.default);
-		});
-	} else i18nLoadedCallback?.(i18next.default);
+	if (!i18next.default.isInitialized && require_util.isServerSide()) i18next.default.use(fsBackend()).use(require_requestLanguageDetector.createRequestLanguageDetector()).init({
+		...require_i18SharedOptions.i18nSharedOptions,
+		ns: [
+			require_translationKey.NAMESPACES.server,
+			require_translationKey.NAMESPACES.widget,
+			require_translationKey.NAMESPACES.target
+		],
+		defaultNS: require_translationKey.NAMESPACES.server,
+		fallbackNS: [require_translationKey.NAMESPACES.widget, require_translationKey.NAMESPACES.target],
+		backend: { loadPath }
+	}, () => {
+		i18nLoadedCallback?.(i18next.default);
+	});
+	else i18nLoadedCallback?.(i18next.default);
 	return i18next.default;
 }
 //#endregion
 exports.default = initializeI18n;
 exports.initializeI18n = initializeI18n;
+exports.fsBackend = fsBackend;
+exports.localesDirectory = localesDirectory;

package/dist/cjs/i18nFrontend.cjs

@@ -1,11 +1,11 @@
+const require_languagePreference = require("./languagePreference.cjs");
+const require_widget = require("./locales/en/widget.cjs");
+const require_translationKey = require("./translationKey.cjs");
 const require_i18SharedOptions = require("./i18SharedOptions.cjs");
 let _prosopo_util = require("@prosopo/util");
 //#region src/i18nFrontend.ts
-var NAMESPACE = "translation";
+var NAMESPACE = require_translationKey.NAMESPACES.widget;
 var FALLBACK_LANGUAGE = require_i18SharedOptions.i18nSharedOptions.fallbackLng;
-var STORAGE_KEY = "i18nextLng";
-var COOKIE_KEY = "i18next";
-var COOKIE_MAX_AGE_SECONDS = 10080 * 60;
 /**
 * How long to wait for a catalogue before rendering untranslated.
 *
@@ -14,7 +14,12 @@ var COOKIE_MAX_AGE_SECONDS = 10080 * 60;
 * catalogue that never arrives degrades rather than blocks.
 */
 var CATALOGUE_FETCH_TIMEOUT_MS = 1e4;
-var SUPPORTED_LANGUAGES = require_i18SharedOptions.i18nSharedOptions.supportedLngs;
+/**
+* English ships inside the bundle: the key checks in translationKey.ts import
+* it anyway, and it means the widget always has English text, for its own
+* fallback and for logs and crash reports, without a second fetch.
+*/
+var bundledEnglish = (0, _prosopo_util.flatten)(require_widget.default);
 /**
 * Locale JSON sits next to the bundle that asked for it. The widget is embedded
 * by third parties and cannot know a base URL, but it does know where its own
@@ -25,63 +30,11 @@ var catalogueUrl = (language) => {
 	return `${moduleUrl.slice(0, moduleUrl.lastIndexOf("/"))}/locales/${language}/${NAMESPACE}.json`;
 };
 /**
-* `en-GB` is not in the catalogue list but `en` is, so a regional tag resolves
-* to its base language rather than falling all the way back to English.
-*/
-var resolveLanguage = (candidate) => {
-	if (!candidate) return;
-	if (SUPPORTED_LANGUAGES.includes(candidate)) return candidate;
-	const base = candidate.split("-")[0];
-	return base && SUPPORTED_LANGUAGES.includes(base) ? base : void 0;
-};
-var readCookie = () => {
-	try {
-		const match = document.cookie.match(new RegExp(`(?:^|; )${COOKIE_KEY}=([^;]*)`));
-		return match?.[1] ? decodeURIComponent(match[1]) : void 0;
-	} catch {
-		return;
-	}
-};
-var readStorage = () => {
-	try {
-		return localStorage.getItem(STORAGE_KEY) ?? void 0;
-	} catch {
-		return;
-	}
-};
-var navigatorLanguages = () => {
-	try {
-		return navigator.languages?.length ? navigator.languages : [navigator.language];
-	} catch {
-		return [];
-	}
-};
-/**
-* Cookie and localStorage are both written, matching what the widget did when
-* i18next-browser-languagedetector handled this, so a visitor's choice survives
-* across pages that embed the widget. Either store can throw in a sandboxed
-* iframe or with third-party storage blocked; neither is load-bearing.
+* Only the browser's own list. Nothing is read from or written to cookies or
+* storage: the widget runs on other people's sites, where the i18next cookie
+* and `i18nextLng` key may belong to the site's own i18n.
 */
-var cacheLanguage = (language) => {
-	try {
-		localStorage.setItem(STORAGE_KEY, language);
-	} catch {}
-	try {
-		document.cookie = `${COOKIE_KEY}=${encodeURIComponent(language)};max-age=${COOKIE_MAX_AGE_SECONDS};path=/`;
-	} catch {}
-};
-var detectLanguage = () => {
-	const candidates = [
-		readCookie(),
-		readStorage(),
-		...navigatorLanguages()
-	];
-	for (const candidate of candidates) {
-		const resolved = resolveLanguage(candidate);
-		if (resolved) return resolved;
-	}
-	return FALLBACK_LANGUAGE;
-};
+var detectLanguage = () => require_languagePreference.matchLanguage(require_languagePreference.browserLanguages()) ?? FALLBACK_LANGUAGE;
 var fetchCatalogue = async (language) => {
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(), CATALOGUE_FETCH_TIMEOUT_MS);
@@ -98,26 +51,23 @@ var fetchCatalogue = async (language) => {
 };
 var interpolate = (template, options) => options ? template.replace(/\{\{(\w+)\}\}/g, (placeholder, name) => name in options ? String(options[name]) : placeholder) : template;
 var createBrowserI18n = (requested) => {
-	const catalogues = /* @__PURE__ */ new Map();
+	const catalogues = /* @__PURE__ */ new Map([[FALLBACK_LANGUAGE, bundledEnglish]]);
 	const listeners = /* @__PURE__ */ new Map();
-	let language = resolveLanguage(requested) ?? detectLanguage();
+	let language = require_languagePreference.resolveLanguageList(requested) ?? detectLanguage();
 	let initialised = false;
 	const emit = (event) => {
 		for (const listener of listeners.get(event) ?? []) listener();
 	};
 	/**
-	* The fallback catalogue is fetched alongside the active one so a key
-	* missing from a translation still renders English rather than its key —
-	* the same key-level fallback i18next gave us via `fallbackLng`.
+	* Only the active language's widget namespace is fetched. English is
+	* already loaded, so a key missing from a translation still renders
+	* English rather than its key, the key-level fallback i18next gives via
+	* `fallbackLng`.
 	*/
 	const loadCatalogues = async (target) => {
-		const wanted = [.../* @__PURE__ */ new Set([target, FALLBACK_LANGUAGE])].filter((candidate) => !catalogues.has(candidate));
-		await Promise.all(wanted.map(async (candidate) => {
-			catalogues.set(candidate, await fetchCatalogue(candidate));
-		}));
+		if (!catalogues.has(target)) catalogues.set(target, await fetchCatalogue(target));
 	};
 	const lookup = (candidate, key) => catalogues.get(candidate)?.[key];
-	cacheLanguage(language);
 	const loading = loadCatalogues(language).then(() => {
 		initialised = true;
 		emit("initialized");
@@ -131,12 +81,12 @@ var createBrowserI18n = (requested) => {
 			return initialised;
 		},
 		t: (key, options) => interpolate(lookup(language, key) ?? lookup(FALLBACK_LANGUAGE, key) ?? options?.defaultValue ?? key, options),
+		exists: (key) => lookup(language, key) !== void 0 || lookup(FALLBACK_LANGUAGE, key) !== void 0,
 		hasLoadedNamespace: (namespace) => namespace === NAMESPACE && catalogues.has(language),
 		changeLanguage: async (next) => {
-			const resolved = resolveLanguage(next) ?? FALLBACK_LANGUAGE;
+			const resolved = require_languagePreference.resolveLanguageList(next) ?? FALLBACK_LANGUAGE;
 			if (resolved !== language) {
 				language = resolved;
-				cacheLanguage(resolved);
 				await loadCatalogues(resolved);
 				emit("loaded");
 				emit("languageChanged");

package/dist/cjs/index.cjs

@@ -1,20 +1,41 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_browserUiLanguages = require("./browserUiLanguages.cjs");
 const require_direction = require("./direction.cjs");
 const require_loadI18next = require("./loadI18next.cjs");
 const require_i18nMiddleware = require("./i18nMiddleware.cjs");
 const require_translations = require("./translations.cjs");
+const require_languagePreference = require("./languagePreference.cjs");
 const require_util = require("./util.cjs");
 const require_translationKey = require("./translationKey.cjs");
+const require_serverTranslationKeys = require("./serverTranslationKeys.cjs");
 const require_translator = require("./translator.cjs");
 const require_errorMessage = require("./errorMessage.cjs");
+exports.BROWSER_UI_LANGUAGES = require_browserUiLanguages.BROWSER_UI_LANGUAGES;
+exports.LANGUAGE_HEADER = require_languagePreference.LANGUAGE_HEADER;
+exports.LANGUAGE_QUERY_PARAM = require_languagePreference.LANGUAGE_QUERY_PARAM;
 exports.LanguageCodes = require_translations.LanguageCodes;
 exports.Languages = require_translations.Languages;
+exports.NAMESPACES = require_translationKey.NAMESPACES;
+exports.browserLanguages = require_languagePreference.browserLanguages;
+exports.canTranslate = require_translationKey.canTranslate;
 exports.createTranslator = require_translator.createTranslator;
+exports.englishText = require_serverTranslationKeys.englishText;
 exports.getLanguageDirection = require_direction.getLanguageDirection;
 exports.i18nMiddleware = require_i18nMiddleware.default;
 exports.isClientSide = require_util.isClientSide;
 exports.isLanguage = require_translations.isLanguage;
-exports.isTranslationKey = require_translationKey.isTranslationKey;
+exports.isTargetKey = require_serverTranslationKeys.isTargetKey;
+exports.isTranslationKey = require_serverTranslationKeys.isTranslationKey;
+exports.isWidgetTranslationKey = require_translationKey.isWidgetTranslationKey;
+exports.languageHeaders = require_languagePreference.languageHeaders;
 exports.loadI18next = require_loadI18next.default;
 exports.localiseErrorMessage = require_errorMessage.localiseErrorMessage;
-exports.translationKeys = require_translationKey.translationKeys;
+exports.matchLanguage = require_languagePreference.matchLanguage;
+exports.matchLanguageTag = require_languagePreference.matchLanguageTag;
+exports.negotiateLanguage = require_languagePreference.negotiateLanguage;
+exports.parseLanguageList = require_languagePreference.parseLanguageList;
+exports.requestLanguage = require_languagePreference.requestLanguage;
+exports.resolveLanguageList = require_languagePreference.resolveLanguageList;
+exports.targetKeys = require_serverTranslationKeys.targetKeys;
+exports.translationKeys = require_serverTranslationKeys.translationKeys;
+exports.widgetLanguageHeaders = require_languagePreference.widgetLanguageHeaders;

package/dist/cjs/languagePreference.cjs

@@ -0,0 +1,142 @@
+const require_translations = require("./translations.cjs");
+//#region src/languagePreference.ts
+/** Our own header for the widget's language list, beside the browser's Accept-Language. */
+var LANGUAGE_HEADER = "Prosopo-Lang";
+/** Query parameter for clients that cannot set headers. Wins over both. */
+var LANGUAGE_QUERY_PARAM = "lng";
+var MAX_PREFERENCES = 10;
+var LANGUAGE_TAG = /^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*$/;
+/**
+* Primary subtags we do not have a catalogue for but can serve from one we
+* do: Norwegian Bokmål and Nynorsk read the `no` catalogue, and browsers
+* still send the withdrawn codes for Indonesian and Javanese.
+*/
+var ALIASES = {
+	nb: require_translations.Languages.norwegian,
+	in: require_translations.Languages.indonesian,
+	iw: require_translations.Languages.hebrew,
+	jw: require_translations.Languages.javanese,
+	tl: require_translations.Languages.filipino
+};
+var byLowerCase = new Map(Object.values(require_translations.Languages).map((code) => [code.toLowerCase(), code]));
+/**
+* A comma-separated list in Accept-Language form ("tr-TR, tr;q=0.9, en;q=0.8")
+* as tags, most preferred first. Order is kept between equal weights,
+* `q=0` and `*` entries are dropped, and anything malformed is skipped.
+*/
+var parseLanguageList = (value) => {
+	if (!value) return [];
+	return value.split(",").map((entry, index) => {
+		const [tag = "", ...params] = entry.split(";").map((part) => part.trim());
+		const weight = params.find((param) => /^q=/i.test(param));
+		return {
+			tag,
+			q: weight === void 0 ? 1 : /^q=[0-9]+(?:\.[0-9]*)?$/i.test(weight) ? Number(weight.slice(2)) : NaN,
+			index
+		};
+	}).filter(({ tag, q }) => LANGUAGE_TAG.test(tag) && Number.isFinite(q) && q > 0 && q <= 1).sort((a, b) => b.q - a.q || a.index - b.index).map(({ tag }) => tag).slice(0, MAX_PREFERENCES);
+};
+var TRADITIONAL_CHINESE_SUBTAGS = /* @__PURE__ */ new Set([
+	"hant",
+	"tw",
+	"hk",
+	"mo"
+]);
+var HONG_KONG_CHINESE_SUBTAGS = /* @__PURE__ */ new Set(["hk", "mo"]);
+var isTraditionalChinese = (subtags) => subtags[0] === "zh" && !subtags.includes("hans") && subtags.some((subtag) => TRADITIONAL_CHINESE_SUBTAGS.has(subtag));
+var traditionalChinese = (subtags) => subtags.some((subtag) => HONG_KONG_CHINESE_SUBTAGS.has(subtag)) ? require_translations.Languages.chineseHongKong : require_translations.Languages.chineseTaiwan;
+/**
+* The catalogue for one tag: the exact code, then the tag with its last subtag
+* dropped, and so on (RFC 4647 lookup), so `zh-Hans-SG` reaches `zh` and
+* `pt-BR` stays `pt-BR`. Traditional Chinese (`zh-Hant`, `zh-MO`) goes to
+* `zh-TW` or `zh-HK`, never `zh`. Case is ignored. Aliases apply to the primary subtag.
+*/
+var matchLanguageTag = (tag) => {
+	if (!LANGUAGE_TAG.test(tag)) return;
+	const subtags = tag.toLowerCase().split("-");
+	if (isTraditionalChinese(subtags)) return traditionalChinese(subtags);
+	for (let length = subtags.length; length >= 1; length--) {
+		const match = byLowerCase.get(subtags.slice(0, length).join("-"));
+		if (match) return match;
+	}
+	return subtags[0] === void 0 ? void 0 : ALIASES[subtags[0]];
+};
+/** The first preference we have a catalogue for, or undefined if none. */
+var matchLanguage = (preferences) => {
+	for (const tag of preferences) {
+		const match = matchLanguageTag(tag);
+		if (match) return match;
+	}
+};
+/**
+* A site-supplied list such as `data-language="xx, tr-TR"`: the first entry we
+* have a catalogue for, or undefined if none.
+*/
+var resolveLanguageList = (value) => matchLanguage(parseLanguageList(value ?? void 0));
+/** Like matchLanguage, but falls back to English. */
+var negotiateLanguage = (preferences) => matchLanguage(preferences) ?? require_translations.Languages.english;
+/**
+* The headers the widget sends with every provider request: Prosopo-Lang
+* only. The browser's own Accept-Language is left as it is, because the
+* provider's bot rules read it and a value set by script would hide the real
+* one. Prosopo-Lang beats Accept-Language on the provider, so the site's
+* data-language still wins.
+*/
+var languageHeaders = (preferences) => {
+	const tags = preferences.filter((tag) => LANGUAGE_TAG.test(tag)).slice(0, MAX_PREFERENCES);
+	return tags.length === 0 ? {} : { [LANGUAGE_HEADER]: tags.join(",") };
+};
+/**
+* navigator.languages, most preferred first. Empty outside a browser, and
+* where navigator access throws (some sandboxed iframes).
+*/
+var browserLanguages = () => {
+	try {
+		if (typeof navigator === "undefined") return [];
+		return navigator.languages?.length ? navigator.languages : [navigator.language];
+	} catch {
+		return [];
+	}
+};
+/**
+* The language headers for the widget's provider requests: the site's choice
+* when it made one (already resolved, so the provider cannot pick otherwise),
+* else the browser's list, which the provider negotiates exactly as the
+* widget did.
+*/
+var widgetLanguageHeaders = (siteLanguage) => languageHeaders(siteLanguage ? [siteLanguage] : browserLanguages());
+var firstString = (value) => {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value) && typeof value[0] === "string") return value[0];
+};
+/**
+* The provider's choice for one request: `?lng=` beats the Prosopo-Lang
+* header, which beats Accept-Language. A source naming only languages we do
+* not have is skipped, not taken as English, so the next one still counts.
+* No cookie: the widget runs on other people's sites and must not set one.
+*/
+var requestLanguage = (request) => {
+	const headers = request.headers ?? {};
+	const sources = [
+		firstString(request.query?.["lng"]),
+		firstString(headers[LANGUAGE_HEADER.toLowerCase()]),
+		firstString(headers["accept-language"])
+	];
+	for (const source of sources) {
+		const match = matchLanguage(parseLanguageList(source));
+		if (match) return match;
+	}
+	return require_translations.Languages.english;
+};
+//#endregion
+exports.LANGUAGE_HEADER = LANGUAGE_HEADER;
+exports.LANGUAGE_QUERY_PARAM = LANGUAGE_QUERY_PARAM;
+exports.browserLanguages = browserLanguages;
+exports.languageHeaders = languageHeaders;
+exports.matchLanguage = matchLanguage;
+exports.matchLanguageTag = matchLanguageTag;
+exports.negotiateLanguage = negotiateLanguage;
+exports.parseLanguageList = parseLanguageList;
+exports.requestLanguage = requestLanguage;
+exports.resolveLanguageList = resolveLanguageList;
+exports.widgetLanguageHeaders = widgetLanguageHeaders;

package/dist/cjs/loadI18next.cjs

@@ -3,10 +3,10 @@ var i18nInstance;
 /**
 * How long to wait for i18next to report `loaded` before giving up on it.
 *
-* Resolution is driven by an event, and events are not guaranteed: a backend
-* that never answers (http backend against a dead CDN, fs backend against a
-* missing locales dir) leaves the listener armed and the promise pending for
-* the lifetime of the process. `cli.ts` calls loadI18next(true).then(...) with
+* Resolution is driven by an event, and events are not guaranteed: a catalogue
+* that never arrives (the widget's fetch against a dead CDN, the fs backend
+* against a missing locales dir) leaves the listener armed and the promise
+* pending for the lifetime of the process. `cli.ts` calls loadI18next(true).then(...) with
 * nothing to time it out, so a pending promise there is a silent boot hang with
 * no log line to explain it.
 */