generaltranslation 8.2.7 → 8.2.9

package/dist/core-LS3Pia40.cjs

@@ -0,0 +1,1666 @@
+const require_IntlCache = require("./IntlCache-k2qfrDqB.cjs");
+let intl_messageformat = require("intl-messageformat");
+//#region src/locales/isValidLocale.ts
+const scriptExceptions = [
+	"Cham",
+	"Jamo",
+	"Kawi",
+	"Lisu",
+	"Toto",
+	"Thai"
+];
+const isCustomLanguage = (language) => {
+	return language >= "qaa" && language <= "qtz";
+};
+/**
+* Checks if a given BCP 47 language code is valid.
+* @param {string} code - The BCP 47 language code to validate.
+* @param {CustomMapping} [customMapping] - The custom mapping to use for validation.
+* @returns {boolean} True if the BCP 47 code is valid, false otherwise.
+* @internal
+*/
+const _isValidLocale = (locale, customMapping) => {
+	if (customMapping?.[locale] && typeof customMapping[locale] === "object" && "code" in customMapping[locale] && customMapping[locale].code) locale = customMapping[locale].code;
+	try {
+		const { language, region, script } = require_IntlCache.intlCache.get("Locale", locale);
+		if (locale.split("-").length !== (() => {
+			let partCount = 1;
+			if (region) partCount += 1;
+			if (script) partCount += 1;
+			return partCount;
+		})()) return false;
+		if (require_IntlCache.intlCache.get("DisplayNames", ["en"], { type: "language" }).of(language) === language && !isCustomLanguage(language)) return false;
+		if (region) {
+			if (require_IntlCache.intlCache.get("DisplayNames", ["en"], { type: "region" }).of(region) === region) return false;
+		}
+		if (script) {
+			if (require_IntlCache.intlCache.get("DisplayNames", ["en"], { type: "script" }).of(script) === script && !scriptExceptions.includes(script)) return false;
+		}
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* Standardizes a BCP 47 locale to ensure correct formatting.
+* @param {string} locale - The BCP 47 locale to standardize.
+* @returns {string} The standardized BCP 47 locale, or an empty string if invalid.
+* @internal
+*/
+const _standardizeLocale = (locale) => {
+	try {
+		return Intl.getCanonicalLocales(locale)[0];
+	} catch {
+		return locale;
+	}
+};
+//#endregion
+//#region src/locales/isSameDialect.ts
+function checkTwoLocalesAreSameDialect(codeA, codeB) {
+	const { language: languageA, region: regionA, script: scriptA } = require_IntlCache.intlCache.get("Locale", codeA);
+	const { language: languageB, region: regionB, script: scriptB } = require_IntlCache.intlCache.get("Locale", codeB);
+	if (languageA !== languageB) return false;
+	if (regionA && regionB && regionA !== regionB) return false;
+	if (scriptA && scriptB && scriptA !== scriptB) return false;
+	return true;
+}
+/**
+* Test two or more language codes to determine if they are exactly the same
+* e.g. "en-US" and "en" would be exactly the same.
+* "en-GB" and "en" would be exactly the same.
+* "en-GB" and "en-US" would be different.
+* @internal
+*/
+function _isSameDialect(...locales) {
+	try {
+		const flattenedCodes = locales.flat().map(_standardizeLocale);
+		for (let i = 0; i < flattenedCodes.length; i++) for (let j = i + 1; j < flattenedCodes.length; j++) if (!checkTwoLocalesAreSameDialect(flattenedCodes[i], flattenedCodes[j])) return false;
+		return true;
+	} catch (error) {
+		console.error(error);
+		return false;
+	}
+}
+//#endregion
+//#region src/locales/isSameLanguage.ts
+/**
+* @internal
+*/
+function _isSameLanguage(...locales) {
+	try {
+		const languages = locales.flat().map((locale) => require_IntlCache.intlCache.get("Locale", locale).language);
+		return languages.every((language) => language === languages[0]);
+	} catch (error) {
+		console.error(error);
+		return false;
+	}
+}
+//#endregion
+//#region src/locales/requiresTranslation.ts
+/**
+* Given a target locale and a source locale, determines whether a translation is required
+* If the target locale and the source locale are the same, returns false, otherwise returns true
+* If a translation is not possible due to the target locale being outside of the optional approvedLanguages scope, also returns false
+* @internal
+*/
+function _requiresTranslation(sourceLocale, targetLocale, approvedLocales, customMapping) {
+	if (!_isValidLocale(sourceLocale, customMapping) || !_isValidLocale(targetLocale, customMapping) || approvedLocales && approvedLocales.some((approvedLocale) => !_isValidLocale(approvedLocale, customMapping))) return false;
+	if (_isSameDialect(sourceLocale, targetLocale)) return false;
+	if (approvedLocales && !approvedLocales.some((approvedLocale) => _isSameLanguage(targetLocale, approvedLocale))) return false;
+	return true;
+}
+//#endregion
+//#region src/locales/customLocaleMapping.ts
+const getCustomProperty = (customMapping, locale, property) => {
+	if (customMapping?.[locale]) {
+		if (typeof customMapping[locale] === "string") return property === "name" ? customMapping[locale] : void 0;
+		return customMapping[locale][property];
+	}
+};
+/**
+* Checks if a given locale should use the canonical locale.
+* @param locale - The locale to check if it should use the canonical locale
+* @param customMapping - The custom mapping to use for checking if the locale should use the canonical locale
+* @returns True if the locale should use the canonical locale, false otherwise
+*/
+const shouldUseCanonicalLocale = (locale, customMapping) => {
+	return !!(customMapping?.[locale] && typeof customMapping[locale] === "object" && "code" in customMapping[locale] && customMapping[locale].code && _isValidLocale(customMapping[locale].code));
+};
+//#endregion
+//#region src/locales/getLocaleEmoji.ts
+/**
+* @internal
+*/
+function _getLocaleEmoji(locale, customMapping) {
+	const aliasedLocale = locale;
+	if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) locale = customMapping[locale].code;
+	try {
+		const standardizedLocale = _standardizeLocale(locale);
+		const localeObject = require_IntlCache.intlCache.get("Locale", standardizedLocale);
+		const { language, region } = localeObject;
+		if (customMapping) for (const l of [
+			aliasedLocale,
+			locale,
+			standardizedLocale,
+			language
+		]) {
+			const customEmoji = getCustomProperty(customMapping, l, "emoji");
+			if (customEmoji) return customEmoji;
+		}
+		if (region && emojis[region]) return emojis[region];
+		const extrapolated = localeObject.maximize();
+		const extrapolatedRegion = extrapolated.region || "";
+		return exceptions[extrapolated.language] || emojis[extrapolatedRegion] || "🌍";
+	} catch {
+		return defaultEmoji;
+	}
+}
+const europeAfricaGlobe = "🌍";
+const asiaAustraliaGlobe = "🌏";
+const defaultEmoji = europeAfricaGlobe;
+const exceptions = {
+	ca: europeAfricaGlobe,
+	eu: europeAfricaGlobe,
+	ku: europeAfricaGlobe,
+	bo: asiaAustraliaGlobe,
+	ug: asiaAustraliaGlobe,
+	gd: "🏴󠁧󠁢󠁳󠁣󠁴󠁿",
+	cy: "🏴󠁧󠁢󠁷󠁬󠁳󠁿",
+	gv: "🇮🇲",
+	grc: "🏺"
+};
+const emojis = {
+	AF: "🇦🇫",
+	AX: "🇦🇽",
+	AL: "🇦🇱",
+	DZ: "🇩🇿",
+	AS: "🇦🇸",
+	AD: "🇦🇩",
+	AO: "🇦🇴",
+	AI: "🇦🇮",
+	AQ: "🇦🇶",
+	AG: "🇦🇬",
+	AR: "🇦🇷",
+	AM: "🇦🇲",
+	AW: "🇦🇼",
+	AU: "🇦🇺",
+	AT: "🇦🇹",
+	AZ: "🇦🇿",
+	BS: "🇧🇸",
+	BH: "🇧🇭",
+	BD: "🇧🇩",
+	BB: "🇧🇧",
+	BY: "🇧🇾",
+	BE: "🇧🇪",
+	BZ: "🇧🇿",
+	BJ: "🇧🇯",
+	BM: "🇧🇲",
+	BT: "🇧🇹",
+	BO: "🇧🇴",
+	BQ: "🇧🇶",
+	BA: "🇧🇦",
+	BW: "🇧🇼",
+	BV: "🇧🇻",
+	BR: "🇧🇷",
+	IO: "🇮🇴",
+	BN: "🇧🇳",
+	BG: "🇧🇬",
+	BF: "🇧🇫",
+	BI: "🇧🇮",
+	CV: "🇨🇻",
+	KH: "🇰🇭",
+	CM: "🇨🇲",
+	CA: "🇨🇦",
+	KY: "🇰🇾",
+	CF: "🇨🇫",
+	TD: "🇹🇩",
+	CL: "🇨🇱",
+	CN: "🇨🇳",
+	CX: "🇨🇽",
+	CC: "🇨🇨",
+	CO: "🇨🇴",
+	KM: "🇰🇲",
+	CD: "🇨🇩",
+	CG: "🇨🇬",
+	CK: "🇨🇰",
+	CR: "🇨🇷",
+	CI: "🇨🇮",
+	HR: "🇭🇷",
+	CU: "🇨🇺",
+	CW: "🇨🇼",
+	CY: "🇨🇾",
+	CZ: "🇨🇿",
+	DK: "🇩🇰",
+	DJ: "🇩🇯",
+	DM: "🇩🇲",
+	DO: "🇩🇴",
+	EC: "🇪🇨",
+	EG: "🇪🇬",
+	SV: "🇸🇻",
+	GQ: "🇬🇶",
+	ER: "🇪🇷",
+	EE: "🇪🇪",
+	SZ: "🇸🇿",
+	ET: "🇪🇹",
+	FK: "🇫🇰",
+	FO: "🇫🇴",
+	FJ: "🇫🇯",
+	FI: "🇫🇮",
+	FR: "🇫🇷",
+	GF: "🇬🇫",
+	PF: "🇵🇫",
+	TF: "🇹🇫",
+	GA: "🇬🇦",
+	GM: "🇬🇲",
+	GE: "🇬🇪",
+	DE: "🇩🇪",
+	GH: "🇬🇭",
+	GI: "🇬🇮",
+	GR: "🇬🇷",
+	GL: "🇬🇱",
+	GD: "🇬🇩",
+	GP: "🇬🇵",
+	GU: "🇬🇺",
+	GT: "🇬🇹",
+	GG: "🇬🇬",
+	GN: "🇬🇳",
+	GW: "🇬🇼",
+	GY: "🇬🇾",
+	HT: "🇭🇹",
+	HM: "🇭🇲",
+	VA: "🇻🇦",
+	HN: "🇭🇳",
+	HK: "🇭🇰",
+	HU: "🇭🇺",
+	IS: "🇮🇸",
+	IN: "🇮🇳",
+	ID: "🇮🇩",
+	IR: "🇮🇷",
+	IQ: "🇮🇶",
+	IE: "🇮🇪",
+	IM: "🇮🇲",
+	IL: "🇮🇱",
+	IT: "🇮🇹",
+	JM: "🇯🇲",
+	JP: "🇯🇵",
+	JE: "🇯🇪",
+	JO: "🇯🇴",
+	KZ: "🇰🇿",
+	KE: "🇰🇪",
+	KI: "🇰🇮",
+	KP: "🇰🇵",
+	KR: "🇰🇷",
+	KW: "🇰🇼",
+	KG: "🇰🇬",
+	LA: "🇱🇦",
+	LV: "🇱🇻",
+	LB: "🇱🇧",
+	LS: "🇱🇸",
+	LR: "🇱🇷",
+	LY: "🇱🇾",
+	LI: "🇱🇮",
+	LT: "🇱🇹",
+	LU: "🇱🇺",
+	MO: "🇲🇴",
+	MG: "🇲🇬",
+	MW: "🇲🇼",
+	MY: "🇲🇾",
+	MV: "🇲🇻",
+	ML: "🇲🇱",
+	MT: "🇲🇹",
+	MH: "🇲🇭",
+	MQ: "🇲🇶",
+	MR: "🇲🇷",
+	MU: "🇲🇺",
+	YT: "🇾🇹",
+	MX: "🇲🇽",
+	FM: "🇫🇲",
+	MD: "🇲🇩",
+	MC: "🇲🇨",
+	MN: "🇲🇳",
+	ME: "🇲🇪",
+	MS: "🇲🇸",
+	MA: "🇲🇦",
+	MZ: "🇲🇿",
+	MM: "🇲🇲",
+	NA: "🇳🇦",
+	NR: "🇳🇷",
+	NP: "🇳🇵",
+	NL: "🇳🇱",
+	NC: "🇳🇨",
+	NZ: "🇳🇿",
+	NI: "🇳🇮",
+	NE: "🇳🇪",
+	NG: "🇳🇬",
+	NU: "🇳🇺",
+	NF: "🇳🇫",
+	MK: "🇲🇰",
+	MP: "🇲🇵",
+	NO: "🇳🇴",
+	OM: "🇴🇲",
+	PK: "🇵🇰",
+	PW: "🇵🇼",
+	PS: "🇵🇸",
+	PA: "🇵🇦",
+	PG: "🇵🇬",
+	PY: "🇵🇾",
+	PE: "🇵🇪",
+	PH: "🇵🇭",
+	PN: "🇵🇳",
+	PL: "🇵🇱",
+	PT: "🇵🇹",
+	PR: "🇵🇷",
+	QA: "🇶🇦",
+	RE: "🇷🇪",
+	RO: "🇷🇴",
+	RU: "🇷🇺",
+	RW: "🇷🇼",
+	BL: "🇧🇱",
+	SH: "🇸🇭",
+	KN: "🇰🇳",
+	LC: "🇱🇨",
+	MF: "🇲🇫",
+	PM: "🇵🇲",
+	VC: "🇻🇨",
+	WS: "🇼🇸",
+	SM: "🇸🇲",
+	ST: "🇸🇹",
+	SA: "🇸🇦",
+	SN: "🇸🇳",
+	RS: "🇷🇸",
+	SC: "🇸🇨",
+	SL: "🇸🇱",
+	SG: "🇸🇬",
+	SX: "🇸🇽",
+	SK: "🇸🇰",
+	SI: "🇸🇮",
+	SB: "🇸🇧",
+	SO: "🇸🇴",
+	ZA: "🇿🇦",
+	GS: "🇬🇸",
+	SS: "🇸🇸",
+	ES: "🇪🇸",
+	LK: "🇱🇰",
+	SD: "🇸🇩",
+	SR: "🇸🇷",
+	SJ: "🇸🇯",
+	SE: "🇸🇪",
+	CH: "🇨🇭",
+	SY: "🇸🇾",
+	TW: "🇹🇼",
+	TJ: "🇹🇯",
+	TZ: "🇹🇿",
+	TH: "🇹🇭",
+	TL: "🇹🇱",
+	TG: "🇹🇬",
+	TK: "🇹🇰",
+	TO: "🇹🇴",
+	TT: "🇹🇹",
+	TN: "🇹🇳",
+	TR: "🇹🇷",
+	TM: "🇹🇲",
+	TC: "🇹🇨",
+	TV: "🇹🇻",
+	UG: "🇺🇬",
+	UA: "🇺🇦",
+	AE: "🇦🇪",
+	GB: "🇬🇧",
+	US: "🇺🇸",
+	UM: "🇺🇲",
+	UY: "🇺🇾",
+	UZ: "🇺🇿",
+	VU: "🇻🇺",
+	VE: "🇻🇪",
+	VN: "🇻🇳",
+	VG: "🇻🇬",
+	VI: "🇻🇮",
+	WF: "🇼🇫",
+	EH: "🇪🇭",
+	YE: "🇾🇪",
+	ZM: "🇿🇲",
+	ZW: "🇿🇼",
+	EU: "🇪🇺",
+	"419": "🌎"
+};
+//#endregion
+//#region src/locales/getLocaleProperties.ts
+/**
+* Creates a set of custom locale properties from a custom mapping.
+*
+* @param lArray - An array of locale codes to search for in the custom mapping.
+* @param customMapping - Optional custom mapping of locale codes to names.
+* @returns A partial set of locale properties, or undefined if no custom mapping is provided.
+*/
+function createCustomLocaleProperties(lArray, customMapping) {
+	if (customMapping) {
+		let merged = {};
+		for (const l of lArray) {
+			const value = customMapping[l];
+			if (value) {
+				if (typeof value === "string") merged.name ||= value;
+				else if (value) merged = {
+					...value,
+					...merged
+				};
+			}
+		}
+		return merged;
+	}
+}
+/**
+* @internal
+*/
+function _getLocaleProperties(locale, defaultLocale = "en", customMapping) {
+	const aliasedLocale = locale;
+	if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) locale = customMapping[locale].code;
+	defaultLocale ||= "en";
+	try {
+		const standardizedLocale = _standardizeLocale(locale);
+		const localeObject = require_IntlCache.intlCache.get("Locale", locale);
+		const languageCode = localeObject.language;
+		const customLocaleProperties = createCustomLocaleProperties([
+			aliasedLocale,
+			locale,
+			standardizedLocale,
+			languageCode
+		], customMapping);
+		const baseRegion = localeObject.region;
+		const maximizedLocale = localeObject.maximize();
+		const maximizedCode = maximizedLocale.toString();
+		const regionCode = localeObject.region || customLocaleProperties?.regionCode || maximizedLocale.region || "";
+		const scriptCode = localeObject.script || customLocaleProperties?.scriptCode || maximizedLocale.script || "";
+		const minimizedCode = localeObject.minimize().toString();
+		const defaultLanguageOrder = [
+			defaultLocale,
+			locale,
+			"en"
+		];
+		const nativeLanguageOrder = [
+			locale,
+			defaultLocale,
+			"en"
+		];
+		const languageNames = require_IntlCache.intlCache.get("DisplayNames", defaultLanguageOrder, { type: "language" });
+		const nativeLanguageNames = require_IntlCache.intlCache.get("DisplayNames", nativeLanguageOrder, { type: "language" });
+		const customName = customLocaleProperties?.name;
+		const customNativeName = customLocaleProperties?.nativeName || customLocaleProperties?.name;
+		const name = customName || languageNames.of(locale) || locale;
+		const nativeName = customNativeName || nativeLanguageNames.of(locale) || locale;
+		const maximizedName = customLocaleProperties?.maximizedName || customName || languageNames.of(maximizedCode) || locale;
+		const nativeMaximizedName = customLocaleProperties?.nativeMaximizedName || customNativeName || nativeLanguageNames.of(maximizedCode) || locale;
+		const minimizedName = customLocaleProperties?.minimizedName || customName || languageNames.of(minimizedCode) || locale;
+		const nativeMinimizedName = customLocaleProperties?.nativeMinimizedName || customNativeName || nativeLanguageNames.of(minimizedCode) || locale;
+		const languageName = customLocaleProperties?.languageName || customName || languageNames.of(languageCode) || locale;
+		const nativeLanguageName = customLocaleProperties?.nativeLanguageName || customNativeName || nativeLanguageNames.of(languageCode) || locale;
+		const nameWithRegionCode = customLocaleProperties?.nameWithRegionCode || baseRegion ? `${languageName} (${baseRegion})` : name;
+		const nativeNameWithRegionCode = customLocaleProperties?.nativeNameWithRegionCode || (baseRegion ? `${nativeLanguageName} (${baseRegion})` : nativeName) || nameWithRegionCode;
+		const regionNames = require_IntlCache.intlCache.get("DisplayNames", defaultLanguageOrder, { type: "region" });
+		const nativeRegionNames = require_IntlCache.intlCache.get("DisplayNames", nativeLanguageOrder, { type: "region" });
+		const regionName = customLocaleProperties?.regionName || (regionCode ? regionNames.of(regionCode) : "") || "";
+		const nativeRegionName = customLocaleProperties?.nativeRegionName || (regionCode ? nativeRegionNames.of(regionCode) : "") || "";
+		const scriptNames = require_IntlCache.intlCache.get("DisplayNames", defaultLanguageOrder, { type: "script" });
+		const nativeScriptNames = require_IntlCache.intlCache.get("DisplayNames", nativeLanguageOrder, { type: "script" });
+		return {
+			code: standardizedLocale,
+			name,
+			nativeName,
+			maximizedCode,
+			maximizedName,
+			nativeMaximizedName,
+			minimizedCode,
+			minimizedName,
+			nativeMinimizedName,
+			languageCode,
+			languageName,
+			nativeLanguageName,
+			nameWithRegionCode,
+			nativeNameWithRegionCode,
+			regionCode,
+			regionName,
+			nativeRegionName,
+			scriptCode,
+			scriptName: customLocaleProperties?.scriptName || (scriptCode ? scriptNames.of(scriptCode) : "") || "",
+			nativeScriptName: customLocaleProperties?.nativeScriptName || (scriptCode ? nativeScriptNames.of(scriptCode) : "") || "",
+			emoji: customLocaleProperties?.emoji || _getLocaleEmoji(standardizedLocale, customMapping)
+		};
+	} catch {
+		let code = _isValidLocale(locale) ? _standardizeLocale(locale) : locale;
+		const codeParts = code?.split("-");
+		let languageCode = codeParts?.[0] || code || "";
+		let regionCode = codeParts.length > 2 ? codeParts?.[2] : codeParts?.[1] || "";
+		let scriptCode = codeParts?.[3] || "";
+		const customLocaleProperties = createCustomLocaleProperties([code, languageCode], customMapping);
+		code = customLocaleProperties?.code || code;
+		const name = customLocaleProperties?.name || code;
+		const nativeName = customLocaleProperties?.nativeName || name;
+		const maximizedCode = customLocaleProperties?.maximizedCode || code;
+		const maximizedName = customLocaleProperties?.maximizedName || name;
+		const nativeMaximizedName = customLocaleProperties?.nativeMaximizedName || nativeName;
+		const minimizedCode = customLocaleProperties?.minimizedCode || code;
+		const minimizedName = customLocaleProperties?.minimizedName || name;
+		const nativeMinimizedName = customLocaleProperties?.nativeMinimizedName || nativeName;
+		languageCode = customLocaleProperties?.languageCode || languageCode;
+		const languageName = customLocaleProperties?.languageName || name;
+		const nativeLanguageName = customLocaleProperties?.nativeLanguageName || nativeName;
+		regionCode = customLocaleProperties?.regionCode || regionCode;
+		const regionName = customLocaleProperties?.regionName || "";
+		const nativeRegionName = customLocaleProperties?.nativeRegionName || "";
+		scriptCode = customLocaleProperties?.scriptCode || scriptCode;
+		const scriptName = customLocaleProperties?.scriptName || "";
+		const nativeScriptName = customLocaleProperties?.nativeScriptName || "";
+		const nameWithRegionCode = customLocaleProperties?.nameWithRegionCode || (regionName ? `${languageName} (${regionName})` : name);
+		const nativeNameWithRegionCode = customLocaleProperties?.nativeNameWithRegionCode || (nativeRegionName ? `${nativeLanguageName} (${nativeRegionName})` : nativeName);
+		const emoji = customLocaleProperties?.emoji || "🌍";
+		return {
+			code,
+			name,
+			nativeName,
+			maximizedCode,
+			maximizedName,
+			nativeMaximizedName,
+			minimizedCode,
+			minimizedName,
+			nativeMinimizedName,
+			languageCode,
+			languageName,
+			nativeLanguageName,
+			nameWithRegionCode,
+			nativeNameWithRegionCode,
+			regionCode,
+			regionName,
+			nativeRegionName,
+			scriptCode,
+			scriptName,
+			nativeScriptName,
+			emoji
+		};
+	}
+}
+//#endregion
+//#region src/locales/determineLocale.ts
+/**
+* Given a list of locales and a list of approved locales, sorted in preference order
+* Determines which locale is the best match among the approved locales, prioritizing exact matches and falling back to dialects of the same language
+* @internal
+*/
+function _determineLocale(locales, approvedLocales, customMapping) {
+	if (typeof locales === "string") locales = [locales];
+	locales = locales.filter((locale) => _isValidLocale(locale, customMapping)).map(_standardizeLocale);
+	approvedLocales = approvedLocales.filter((locale) => _isValidLocale(locale, customMapping)).map(_standardizeLocale);
+	for (const locale of locales) {
+		const candidates = approvedLocales.filter((approvedLocale) => _isSameLanguage(locale, approvedLocale));
+		const getMatchingCode = ({ locale, languageCode, minimizedCode, regionCode, scriptCode }) => {
+			const locales = [
+				locale,
+				`${languageCode}-${regionCode}`,
+				`${languageCode}-${scriptCode}`,
+				minimizedCode
+			];
+			for (const l of locales) if (candidates.includes(l)) return l;
+			return null;
+		};
+		const { languageCode, ...codes } = _getLocaleProperties(locale);
+		const matchingCode = getMatchingCode({
+			locale,
+			languageCode,
+			...codes
+		}) || getMatchingCode({
+			locale: languageCode,
+			..._getLocaleProperties(languageCode)
+		});
+		if (matchingCode) return matchingCode;
+	}
+}
+//#endregion
+//#region src/logging/logger.ts
+const LOG_LEVELS = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3,
+	off: 4
+};
+const LOG_COLORS = {
+	debug: "\x1B[36m",
+	info: "\x1B[32m",
+	warn: "\x1B[33m",
+	error: "\x1B[31m",
+	off: ""
+};
+const RESET_COLOR = "\x1B[0m";
+/**
+* Get the configured log level from environment variable or default to 'warn'
+*/
+function getConfiguredLogLevel() {
+	if (typeof process !== "undefined" && process.env?._GT_LOG_LEVEL) {
+		const envLevel = process.env._GT_LOG_LEVEL.toLowerCase();
+		if (envLevel in LOG_LEVELS) return envLevel;
+	}
+	return "warn";
+}
+/**
+* Console log handler that outputs formatted messages to console
+*/
+var ConsoleLogHandler = class {
+	constructor(config) {
+		this.config = config;
+	}
+	handle(entry) {
+		const parts = [];
+		if (this.config.includeTimestamp) parts.push(`[${entry.timestamp.toISOString()}]`);
+		const colorCode = LOG_COLORS[entry.level];
+		const levelText = `[${entry.level.toUpperCase()}]`;
+		parts.push(`${colorCode}${levelText}${RESET_COLOR}`);
+		if (this.config.prefix) parts.push(`[${this.config.prefix}]`);
+		if (this.config.includeContext && entry.context) parts.push(`[${entry.context}]`);
+		parts.push(entry.message);
+		if (entry.metadata && Object.keys(entry.metadata).length > 0) parts.push(`\n  Metadata: ${JSON.stringify(entry.metadata, null, 2)}`);
+		const formattedMessage = parts.join(" ");
+		switch (entry.level) {
+			case "debug":
+				console.debug(formattedMessage);
+				break;
+			case "info":
+				console.info(formattedMessage);
+				break;
+			case "warn":
+				console.warn(formattedMessage);
+				break;
+			case "error":
+				console.error(formattedMessage);
+				break;
+		}
+	}
+};
+/**
+* Main Logger class providing structured logging capabilities
+*/
+var Logger = class {
+	constructor(config = {}) {
+		this.config = {
+			level: getConfiguredLogLevel(),
+			includeTimestamp: true,
+			includeContext: true,
+			enableConsole: true,
+			handlers: [],
+			...config
+		};
+		this.handlers = [...this.config.handlers || []];
+		if (this.config.enableConsole) this.handlers.push(new ConsoleLogHandler(this.config));
+	}
+	/**
+	* Add a custom log handler
+	*/
+	addHandler(handler) {
+		this.handlers.push(handler);
+	}
+	/**
+	* Remove a log handler
+	*/
+	removeHandler(handler) {
+		const index = this.handlers.indexOf(handler);
+		if (index > -1) this.handlers.splice(index, 1);
+	}
+	/**
+	* Update logger configuration
+	*/
+	configure(config) {
+		this.config = {
+			...this.config,
+			...config
+		};
+	}
+	/**
+	* Check if a log level should be output based on current configuration
+	*/
+	shouldLog(level) {
+		return LOG_LEVELS[level] >= LOG_LEVELS[this.config.level];
+	}
+	/**
+	* Internal logging method that creates log entries and passes them to handlers
+	*/
+	log(level, message, context, metadata) {
+		if (!this.shouldLog(level)) return;
+		const entry = {
+			level,
+			message,
+			timestamp: /* @__PURE__ */ new Date(),
+			context,
+			metadata
+		};
+		this.handlers.forEach((handler) => {
+			try {
+				handler.handle(entry);
+			} catch (error) {
+				console.error("Error in log handler:", error);
+			}
+		});
+	}
+	/**
+	* Log a debug message
+	* Used for detailed diagnostic information, typically of interest only when diagnosing problems
+	*/
+	debug(message, context, metadata) {
+		this.log("debug", message, context, metadata);
+	}
+	/**
+	* Log an info message
+	* Used for general information about application operation
+	*/
+	info(message, context, metadata) {
+		this.log("info", message, context, metadata);
+	}
+	/**
+	* Log a warning message
+	* Used for potentially problematic situations that don't prevent operation
+	*/
+	warn(message, context, metadata) {
+		this.log("warn", message, context, metadata);
+	}
+	/**
+	* Log an error message
+	* Used for error events that might still allow the application to continue
+	*/
+	error(message, context, metadata) {
+		this.log("error", message, context, metadata);
+	}
+	/**
+	* Create a child logger with a specific context
+	*/
+	child(context) {
+		return new ContextLogger(this, context);
+	}
+	/**
+	* Get current logger configuration
+	*/
+	getConfig() {
+		return { ...this.config };
+	}
+};
+/**
+* Context logger that automatically includes context information
+*/
+var ContextLogger = class ContextLogger {
+	constructor(logger, context) {
+		this.logger = logger;
+		this.context = context;
+	}
+	debug(message, metadata) {
+		this.logger.debug(message, this.context, metadata);
+	}
+	info(message, metadata) {
+		this.logger.info(message, this.context, metadata);
+	}
+	warn(message, metadata) {
+		this.logger.warn(message, this.context, metadata);
+	}
+	error(message, metadata) {
+		this.logger.error(message, this.context, metadata);
+	}
+	child(childContext) {
+		return new ContextLogger(this.logger, `${this.context}:${childContext}`);
+	}
+};
+const defaultLogger = new Logger({
+	level: getConfiguredLogLevel(),
+	includeTimestamp: true,
+	includeContext: true,
+	prefix: "GT"
+});
+const fetchLogger = defaultLogger.child("fetch");
+defaultLogger.child("validation");
+defaultLogger.child("formatting");
+defaultLogger.child("locale");
+const gtInstanceLogger = defaultLogger.child("GT instance");
+//#endregion
+//#region src/formatting/format.ts
+/**
+* Formats a string value with cutoff behavior according to the specified locales and options.
+*
+* @param {Object} params - The parameters for the cutoff formatting.
+* @param {string} params.value - The string value to format with cutoff behavior.
+* @param {string | string[]} [params.locales='en'] - The locales to use for formatting.
+* @param {CutoffFormatOptions} [params.options={}] - Additional options for cutoff formatting.
+* @param {number} [params.options.maxChars] - The maximum number of characters to display.
+* @param {CutoffFormatStyle} [params.options.style='ellipsis'] - The style of the terminator.
+* @param {string} [params.options.terminator] - Optional override for the terminator to use.
+* @param {string} [params.options.separator] - Optional override for the separator between terminator and value.
+*
+* @returns {string} The formatted string with terminator applied if cutoff occurs.
+* @internal
+*
+* @example
+* _formatCutoff({ value: 'Hello, world!', options: { maxChars: 8 } }); // Returns 'Hello, w...'
+*
+* Will fallback to an empty string if formatting fails.
+*/
+function _formatCutoff({ value, locales = "en", options = {} }) {
+	return require_IntlCache.intlCache.get("CutoffFormat", locales, options).format(value);
+}
+/**
+* Formats a message according to the specified locales and options.
+*
+* @param {string} message - The message to format.
+* @param {string | string[]} [locales='en'] - The locales to use for formatting.
+* @param {Record<string, any>} [variables={}] - The variables to use for formatting.
+* @returns {string} The formatted message.
+* @internal
+*
+* Will fallback to an empty string
+* TODO: add this to custom formats
+*/
+function _formatMessageICU(message, locales = "en", variables = {}) {
+	return new intl_messageformat.IntlMessageFormat(message, locales).format(variables)?.toString() ?? "";
+}
+/**
+* Returns the message as-is without any formatting.
+*
+* @param {string} message - The message to return.
+* @returns {string} The original message, unchanged.
+* @internal
+*
+* TODO: add this to custom formats
+*/
+function _formatMessageString(message) {
+	return message;
+}
+/**
+* Formats a number according to the specified locales and options.
+*
+* @param {Object} params - The parameters for the number formatting.
+* @param {number} params.value - The number to format.
+* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+* @param {Intl.NumberFormatOptions} [params.options={}] - Additional options for number formatting.
+*
+* @returns {string} The formatted number.
+* @internal
+*/
+function _formatNum({ value, locales = ["en"], options = {} }) {
+	return require_IntlCache.intlCache.get("NumberFormat", locales, {
+		numberingSystem: "latn",
+		...options
+	}).format(value);
+}
+/**
+* Formats a date according to the specified locales and options.
+*
+* @param {Object} params - The parameters for the date formatting.
+* @param {Date} params.value - The date to format.
+* @param {string | string[]} [params.locales='en'] - The locales to use for formatting.
+* @param {Intl.DateTimeFormatOptions} [params.options={}] - Additional options for date formatting.
+*
+* @returns {string} The formatted date.
+* @internal
+*/
+function _formatDateTime({ value, locales = ["en"], options = {} }) {
+	return require_IntlCache.intlCache.get("DateTimeFormat", locales, {
+		calendar: "gregory",
+		numberingSystem: "latn",
+		...options
+	}).format(value);
+}
+/**
+* Formats a currency value according to the specified locales, currency, and options.
+*
+* @param {Object} params - The parameters for the currency formatting.
+* @param {number} params.value - The currency value to format.
+* @param {string} params.currency - The currency code (e.g., 'USD').
+* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+* @param {Intl.NumberFormatOptions} [params.options={}] - Additional options for currency formatting.
+*
+* @returns {string} The formatted currency value.
+* @internal
+*/
+function _formatCurrency({ value, locales = ["en"], currency = "USD", options = {} }) {
+	return require_IntlCache.intlCache.get("NumberFormat", locales, {
+		style: "currency",
+		currency,
+		numberingSystem: "latn",
+		...options
+	}).format(value);
+}
+/**
+* Formats a list of items according to the specified locales and options.
+*
+* @param {Object} params - The parameters for the list formatting.
+* @param {Array<string | number>} params.value - The list of items to format.
+* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+* @param {Intl.ListFormatOptions} [params.options={}] - Additional options for list formatting.
+*
+* @returns {string} The formatted list.
+* @internal
+*/
+function _formatList({ value, locales = ["en"], options = {} }) {
+	return require_IntlCache.intlCache.get("ListFormat", locales, {
+		type: "conjunction",
+		style: "long",
+		...options
+	}).format(value);
+}
+/**
+* Formats a list of items according to the specified locales and options.
+* @param {Object} params - The parameters for the list formatting.
+* @param {Array<T>} params.value - The list of items to format.
+* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+* @param {Intl.ListFormatOptions} [params.options={}] - Additional options for list formatting.
+* @returns {Array<T | string>} The formatted list parts.
+* @internal
+*/
+function _formatListToParts({ value, locales = ["en"], options = {} }) {
+	const formatListParts = require_IntlCache.intlCache.get("ListFormat", locales, {
+		type: "conjunction",
+		style: "long",
+		...options
+	}).formatToParts(value.map(() => "1"));
+	let partIndex = 0;
+	return formatListParts.map((part) => {
+		if (part.type === "element") return value[partIndex++];
+		return part.value;
+	});
+}
+/**
+* Selects the best unit and computes the value for relative time formatting
+* based on the difference between a date and a base date.
+* @param {Date} date - The target date.
+* @param {Date} baseDate - The base date to compute relative time from. Must be provided by the caller for hydration safety.
+* @returns {{ value: number, unit: Intl.RelativeTimeFormatUnit }} The computed value and unit.
+* @internal
+*/
+function _selectRelativeTimeUnit(date, baseDate) {
+	const now = baseDate.getTime();
+	const diffMs = date.getTime() - now;
+	const absDiffMs = Math.abs(diffMs);
+	const sign = diffMs < 0 ? -1 : 1;
+	const seconds = Math.floor(absDiffMs / 1e3);
+	const minutes = Math.floor(absDiffMs / (1e3 * 60));
+	const hours = Math.floor(absDiffMs / (1e3 * 60 * 60));
+	const days = Math.floor(absDiffMs / (1e3 * 60 * 60 * 24));
+	const weeks = Math.floor(absDiffMs / (1e3 * 60 * 60 * 24 * 7));
+	const months = Math.floor(absDiffMs / (1e3 * 60 * 60 * 24 * 30));
+	const years = Math.floor(absDiffMs / (1e3 * 60 * 60 * 24 * 365));
+	if (seconds < 60) return {
+		value: sign * seconds,
+		unit: "second"
+	};
+	if (minutes < 60) return {
+		value: sign * minutes,
+		unit: "minute"
+	};
+	if (hours < 24) return {
+		value: sign * hours,
+		unit: "hour"
+	};
+	if (days < 7) return {
+		value: sign * days,
+		unit: "day"
+	};
+	if (days < 28) return {
+		value: sign * weeks,
+		unit: "week"
+	};
+	if (months < 1) return {
+		value: sign * weeks,
+		unit: "week"
+	};
+	if (months < 12) return {
+		value: sign * months,
+		unit: "month"
+	};
+	if (years < 1) return {
+		value: sign * months,
+		unit: "month"
+	};
+	return {
+		value: sign * years,
+		unit: "year"
+	};
+}
+/**
+* Formats a relative time from a Date, automatically selecting the best unit.
+* @internal
+*/
+function _formatRelativeTimeFromDate({ date, baseDate, locales = ["en"], options = {} }) {
+	const { value, unit } = _selectRelativeTimeUnit(date, baseDate);
+	return _formatRelativeTime({
+		value,
+		unit,
+		locales,
+		options
+	});
+}
+/**
+* Formats a relative time value according to the specified locales and options.
+*
+* @param {Object} params - The parameters for the relative time formatting.
+* @param {number} params.value - The relative time value to format.
+* @param {Intl.RelativeTimeFormatUnit} params.unit - The unit of time (e.g., 'second', 'minute', 'hour', 'day', 'week', 'month', 'year').
+* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+* @param {Intl.RelativeTimeFormatOptions} [params.options={}] - Additional options for relative time formatting.
+*
+* @returns {string} The formatted relative time string.
+* @internal
+*/
+function _formatRelativeTime({ value, unit, locales = ["en"], options = {} }) {
+	return require_IntlCache.intlCache.get("RelativeTimeFormat", locales, {
+		style: "long",
+		numeric: "auto",
+		...options
+	}).format(value, unit);
+}
+//#endregion
+//#region src/locales/getLocaleName.ts
+/**
+* Retrieves the display name(s) of locale code(s) using Intl.DisplayNames.
+*
+* @param {string} locale - A BCP-47 locale code.
+* @param {string} [defaultLocale=libraryDefaultLocale] - The locale for display names.
+* @returns {string} The display name(s) corresponding to the code(s), or empty string(s) if invalid.
+* @internal
+*/
+function _getLocaleName(locale, defaultLocale = "en", customMapping) {
+	const aliasedLocale = locale;
+	if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) locale = customMapping[locale].code;
+	defaultLocale ||= "en";
+	try {
+		const standardizedLocale = _standardizeLocale(locale);
+		if (customMapping) for (const l of [
+			aliasedLocale,
+			locale,
+			standardizedLocale,
+			require_IntlCache.intlCache.get("Locale", standardizedLocale).language
+		]) {
+			const customName = getCustomProperty(customMapping, l, "name");
+			if (customName) return customName;
+		}
+		return require_IntlCache.intlCache.get("DisplayNames", [
+			defaultLocale,
+			standardizedLocale,
+			"en"
+		], { type: "language" }).of(standardizedLocale) || "";
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region src/locales/getLocaleDirection.ts
+/**
+* Get the text direction for a given locale code using the Intl.Locale API.
+*
+* @param {string} code - The locale code to check.
+* @returns {string} - 'rtl' if the language is right-to-left, otherwise 'ltr'.
+* @internal
+*/
+function _getLocaleDirection(code) {
+	try {
+		const textInfoDirection = extractDirectionWithTextInfo(require_IntlCache.intlCache.get("Locale", code));
+		if (textInfoDirection) return textInfoDirection;
+	} catch {}
+	const { scriptCode, languageCode } = _getLocaleProperties(code);
+	if (scriptCode) return isRtlScript(scriptCode) ? "rtl" : "ltr";
+	if (languageCode) return isRtlLanguage(languageCode) ? "rtl" : "ltr";
+	return "ltr";
+}
+const RTL_SCRIPTS = new Set([
+	"arab",
+	"adlm",
+	"hebr",
+	"nkoo",
+	"rohg",
+	"samr",
+	"syrc",
+	"thaa",
+	"yezi"
+]);
+const RTL_LANGUAGES = new Set([
+	"ar",
+	"arc",
+	"ckb",
+	"dv",
+	"fa",
+	"he",
+	"iw",
+	"ku",
+	"lrc",
+	"nqo",
+	"ps",
+	"pnb",
+	"sd",
+	"syr",
+	"ug",
+	"ur",
+	"yi"
+]);
+/**
+* Handles extracting direction via textInfo property
+* @param Locale - Intl.Locale object
+* @returns {'ltr' | 'rtl'} - The direction of the locale
+*
+* Intl.Locale.prototype.getTextInfo() / textInfo property incorporated in ES2024 Specification.
+* This is not supported by all browsers yet.
+* See: {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/getTextInfo#browser_compatibility}
+*/
+function extractDirectionWithTextInfo(locale) {
+	if ("textInfo" in locale && typeof locale.textInfo === "object" && locale.textInfo !== null && "direction" in locale.textInfo && (locale.textInfo?.direction === "rtl" || locale.textInfo?.direction === "ltr")) return locale.textInfo?.direction;
+}
+function isRtlScript(script) {
+	return script ? RTL_SCRIPTS.has(script.toLowerCase()) : false;
+}
+function isRtlLanguage(language) {
+	return language ? RTL_LANGUAGES.has(language.toLowerCase()) : false;
+}
+//#endregion
+//#region src/locales/isSupersetLocale.ts
+/**
+* @internal
+*/
+function _isSupersetLocale(superLocale, subLocale) {
+	try {
+		const { language: languageSuper, region: regionSuper, script: scriptSuper } = require_IntlCache.intlCache.get("Locale", _standardizeLocale(superLocale));
+		const { language: languageSub, region: regionSub, script: scriptSub } = require_IntlCache.intlCache.get("Locale", _standardizeLocale(subLocale));
+		if (languageSuper !== languageSub) return false;
+		if (regionSuper && regionSuper !== regionSub) return false;
+		if (scriptSuper && scriptSuper !== scriptSub) return false;
+		return true;
+	} catch (error) {
+		console.error(error);
+		return false;
+	}
+}
+//#endregion
+//#region src/locales/resolveAliasLocale.ts
+/**
+* Resolves the alias locale for a given locale.
+* @param locale - The locale to resolve the alias locale for
+* @param customMapping - The custom mapping to use for resolving the alias locale
+* @returns The alias locale
+*/
+function _resolveAliasLocale(locale, customMapping) {
+	let reverseCustomMapping;
+	if (customMapping) reverseCustomMapping = Object.fromEntries(Object.entries(customMapping).filter(([, value]) => value && typeof value === "object" && "code" in value).map(([key, value]) => [value.code, key]));
+	return reverseCustomMapping?.[locale] || locale;
+}
+//#endregion
+//#region src/locales/resolveCanonicalLocale.ts
+/**
+* Resolves the canonical locale for a given locale.
+* @param locale - The locale to resolve the canonical locale for
+* @param customMapping - The custom mapping to use for resolving the canonical locale
+* @returns The canonical locale
+*/
+function _resolveCanonicalLocale(locale, customMapping) {
+	if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) return customMapping[locale].code;
+	return locale;
+}
+//#endregion
+//#region src/LocaleConfig.ts
+/**
+* LocaleConfig contains the locale and formatting primitives exposed through
+* the core entrypoint.
+*
+* It intentionally does not store project IDs, API keys, runtime URLs, or any
+* translation credentials. It only stores locale metadata needed to resolve
+* aliases, choose formatting fallbacks, and format values with Intl.
+*/
+var LocaleConfig = class {
+	constructor({ defaultLocale = "en", locales = [], customMapping } = {}) {
+		this.defaultLocale = defaultLocale;
+		this.locales = locales;
+		this.customMapping = customMapping;
+	}
+	get translationLocales() {
+		return this.locales.length ? this.locales : void 0;
+	}
+	resolveCanonicalLocaleList(locales) {
+		return locales.map((locale) => this.resolveCanonicalLocale(locale));
+	}
+	resolveCanonicalLocaleArgs(locales) {
+		return locales.map((locale) => Array.isArray(locale) ? this.resolveCanonicalLocaleList(locale) : this.resolveCanonicalLocale(locale));
+	}
+	toLocaleList(locales) {
+		return Array.isArray(locales) ? locales : [locales];
+	}
+	getFormattingLocales(targetLocale, locales) {
+		return (locales !== void 0 ? this.toLocaleList(locales) : [
+			targetLocale,
+			this.defaultLocale,
+			"en"
+		]).filter((locale) => !!locale).map((locale) => this.resolveCanonicalLocale(locale));
+	}
+	formatNum(value, targetLocale, options = {}) {
+		const { locales, ...intlOptions } = options;
+		return _formatNum({
+			value,
+			locales: this.getFormattingLocales(targetLocale, locales),
+			options: intlOptions
+		});
+	}
+	formatDateTime(value, targetLocale, options = {}) {
+		const { locales, ...intlOptions } = options;
+		return _formatDateTime({
+			value,
+			locales: this.getFormattingLocales(targetLocale, locales),
+			options: intlOptions
+		});
+	}
+	formatCurrency(value, currency, targetLocale, options = {}) {
+		const { locales, ...intlOptions } = options;
+		return _formatCurrency({
+			value,
+			currency,
+			locales: this.getFormattingLocales(targetLocale, locales),
+			options: intlOptions
+		});
+	}
+	formatRelativeTime(value, unit, targetLocale, options = {}) {
+		const { locales, ...intlOptions } = options;
+		return _formatRelativeTime({
+			value,
+			unit,
+			locales: this.getFormattingLocales(targetLocale, locales),
+			options: intlOptions
+		});
+	}
+	formatRelativeTimeFromDate(date, targetLocale, options = {}) {
+		const { locales, baseDate, ...intlOptions } = options;
+		return _formatRelativeTimeFromDate({
+			date,
+			baseDate: baseDate ?? /* @__PURE__ */ new Date(),
+			locales: this.getFormattingLocales(targetLocale, locales),
+			options: intlOptions
+		});
+	}
+	formatCutoff(value, targetLocale, options = {}) {
+		const { locales, ...formatOptions } = options;
+		return _formatCutoff({
+			value,
+			locales: this.getFormattingLocales(targetLocale, locales),
+			options: formatOptions
+		});
+	}
+	formatMessage(message, targetLocale, options = {}) {
+		const { locales, variables, dataFormat } = options;
+		if (dataFormat === "STRING") return _formatMessageString(message);
+		return _formatMessageICU(message, this.getFormattingLocales(targetLocale, locales), variables);
+	}
+	formatList(array, targetLocale, options = {}) {
+		const { locales, ...intlOptions } = options;
+		return _formatList({
+			value: array,
+			locales: this.getFormattingLocales(targetLocale, locales),
+			options: intlOptions
+		});
+	}
+	formatListToParts(array, targetLocale, options = {}) {
+		const { locales, ...intlOptions } = options;
+		return _formatListToParts({
+			value: array,
+			locales: this.getFormattingLocales(targetLocale, locales),
+			options: intlOptions
+		});
+	}
+	getLocaleName(locale) {
+		return _getLocaleName(locale, this.defaultLocale, this.customMapping);
+	}
+	getLocaleEmoji(locale) {
+		return _getLocaleEmoji(locale, this.customMapping);
+	}
+	getLocaleProperties(locale) {
+		return _getLocaleProperties(locale, this.defaultLocale, this.customMapping);
+	}
+	requiresTranslation(targetLocale, sourceLocale = this.defaultLocale, approvedLocales = this.translationLocales) {
+		return _requiresTranslation(this.resolveCanonicalLocale(sourceLocale), this.resolveCanonicalLocale(targetLocale), approvedLocales ? this.resolveCanonicalLocaleList(approvedLocales) : void 0, this.customMapping);
+	}
+	determineLocale(locales, approvedLocales = this.locales) {
+		const approvedLocalePairs = approvedLocales.map((locale) => ({
+			locale,
+			canonicalLocale: this.resolveCanonicalLocale(locale)
+		}));
+		const resolvedLocale = _determineLocale(Array.isArray(locales) ? this.resolveCanonicalLocaleList(locales) : this.resolveCanonicalLocale(locales), approvedLocalePairs.map(({ canonicalLocale }) => canonicalLocale), this.customMapping);
+		if (!resolvedLocale) return void 0;
+		return approvedLocalePairs.find(({ canonicalLocale }) => canonicalLocale === resolvedLocale)?.locale || this.resolveAliasLocale(resolvedLocale);
+	}
+	getLocaleDirection(locale) {
+		return _getLocaleDirection(this.resolveCanonicalLocale(locale));
+	}
+	isValidLocale(locale) {
+		return _isValidLocale(locale, this.customMapping);
+	}
+	resolveCanonicalLocale(locale) {
+		return _resolveCanonicalLocale(locale, this.customMapping);
+	}
+	resolveAliasLocale(locale) {
+		return _resolveAliasLocale(locale, this.customMapping);
+	}
+	standardizeLocale(locale) {
+		return _standardizeLocale(locale);
+	}
+	isSameDialect(...locales) {
+		return _isSameDialect(...this.resolveCanonicalLocaleArgs(locales));
+	}
+	isSameLanguage(...locales) {
+		return _isSameLanguage(...this.resolveCanonicalLocaleArgs(locales));
+	}
+	isSupersetLocale(superLocale, subLocale) {
+		return _isSupersetLocale(this.resolveCanonicalLocale(superLocale), this.resolveCanonicalLocale(subLocale));
+	}
+};
+//#endregion
+//#region src/core.ts
+/**
+* Core formatting and locale helpers.
+*
+* This entry point exposes deterministic locale and formatting primitives. It
+* does not export the GT service client, project credentials, network
+* translation methods, file APIs, or other server/service concerns from the
+* root `generaltranslation` facade.
+*
+* This entry point is intended for framework and shared packages that need
+* locale metadata or formatting behavior without pulling in the full
+* translation API surface.
+*/
+/**
+* Formats a string with cutoff behavior, applying a terminator when the string exceeds the maximum character limit.
+*
+* This standalone function provides cutoff formatting functionality without requiring a GT instance.
+* The locales parameter is required for proper terminator selection based on the target language.
+*
+* @param {string} value - The string value to format with cutoff behavior.
+* @param {Object} [options] - Configuration options for cutoff formatting.
+* @param {string | string[]} [options.locales] - The locales to use for terminator selection.
+* @param {number} [options.maxChars] - The maximum number of characters to display.
+* - Undefined values are treated as no cutoff.
+* - Negative values follow .slice() behavior and terminator will be added before the value.
+* - 0 will result in an empty string.
+* - If cutoff results in an empty string, no terminator is added.
+* @param {CutoffFormatStyle} [options.style='ellipsis'] - The style of the terminator.
+* @param {string} [options.terminator] - Optional override the terminator to use.
+* @param {string} [options.separator] - Optional override the separator to use between the terminator and the value.
+* - If no terminator is provided, then separator is ignored.
+* @returns {string} The formatted string with terminator applied if cutoff occurs.
+*
+* @example
+* formatCutoff('Hello, world!', { locales: 'en-US', maxChars: 8 });
+* // Returns: 'Hello, …'
+*
+* @example
+* formatCutoff('Hello, world!', { locales: 'en-US', maxChars: -3 });
+* // Returns: '…d!'
+*
+* @example
+* formatCutoff('Very long text that needs cutting', {
+*   locales: 'en-US',
+*   maxChars: 15,
+*   style: 'ellipsis',
+*   separator: ' '
+* });
+* // Returns: 'Very long tex …'
+*/
+function formatCutoff(value, options) {
+	return _formatCutoff({
+		value,
+		locales: options?.locales,
+		options
+	});
+}
+/**
+* Formats a message according to the specified locales and options.
+*
+* @param {string} message - The message to format.
+* @param {Object} [options] - Configuration options for message formatting.
+* @param {string | string[]} [options.locales] - The locales to use for formatting.
+* @param {FormatVariables} [options.variables] - The variables to use for formatting.
+* @param {StringFormat} [options.dataFormat='ICU'] - The format of the message. When STRING, the message is returned as is.
+* @returns {string} The formatted message.
+*
+* @example
+* formatMessage('Hello {name}', { variables: { name: 'John' } });
+* // Returns: "Hello John"
+*
+* @example
+* formatMessage('Hello {name}', {
+*   locales: ['fr'],
+*   variables: { name: 'John' }
+* });
+*/
+function formatMessage(message, options) {
+	switch (options?.dataFormat) {
+		case "STRING": return _formatMessageString(message);
+		default: return _formatMessageICU(message, options?.locales, options?.variables);
+	}
+}
+/**
+* Checks if a given BCP 47 locale code is valid.
+*
+* @param {string} locale - The BCP 47 locale code to validate.
+* @param {CustomMapping} [customMapping] - The custom mapping to use for validation.
+* @returns {boolean} True if the BCP 47 code is valid, false otherwise.
+*
+* @example
+* isValidLocale('en-US');
+* // Returns: true
+*
+* @example
+* isValidLocale('en_US');
+* // Returns: false
+*/
+function isValidLocale(locale, customMapping) {
+	return _isValidLocale(locale, customMapping);
+}
+/**
+* Resolves the canonical locale for a given locale.
+*
+* @param {string} locale - The locale to resolve the canonical locale for.
+* @param {CustomMapping} [customMapping] - The custom mapping to use for resolving the canonical locale.
+* @returns {string} The canonical locale.
+*
+* @example
+* resolveCanonicalLocale('en-US');
+* // Returns: 'en-US'
+*
+* @example
+* resolveCanonicalLocale('en', { en: 'en-US' });
+* // Returns: 'en-US'
+*/
+function resolveCanonicalLocale(locale, customMapping) {
+	return _resolveCanonicalLocale(locale, customMapping);
+}
+/**
+* Standardizes a BCP 47 locale code to ensure correct formatting.
+*
+* @param {string} locale - The BCP 47 locale code to standardize.
+* @returns {string} The standardized BCP 47 locale code or an empty string if it is an invalid code.
+*
+* @example
+* standardizeLocale('en-us');
+* // Returns: 'en-US'
+*
+* @example
+* standardizeLocale('not a locale');
+* // Returns: ''
+*/
+function standardizeLocale(locale) {
+	return _standardizeLocale(locale);
+}
+//#endregion
+Object.defineProperty(exports, "LocaleConfig", {
+	enumerable: true,
+	get: function() {
+		return LocaleConfig;
+	}
+});
+Object.defineProperty(exports, "_determineLocale", {
+	enumerable: true,
+	get: function() {
+		return _determineLocale;
+	}
+});
+Object.defineProperty(exports, "_formatCurrency", {
+	enumerable: true,
+	get: function() {
+		return _formatCurrency;
+	}
+});
+Object.defineProperty(exports, "_formatDateTime", {
+	enumerable: true,
+	get: function() {
+		return _formatDateTime;
+	}
+});
+Object.defineProperty(exports, "_formatList", {
+	enumerable: true,
+	get: function() {
+		return _formatList;
+	}
+});
+Object.defineProperty(exports, "_formatListToParts", {
+	enumerable: true,
+	get: function() {
+		return _formatListToParts;
+	}
+});
+Object.defineProperty(exports, "_formatNum", {
+	enumerable: true,
+	get: function() {
+		return _formatNum;
+	}
+});
+Object.defineProperty(exports, "_formatRelativeTime", {
+	enumerable: true,
+	get: function() {
+		return _formatRelativeTime;
+	}
+});
+Object.defineProperty(exports, "_formatRelativeTimeFromDate", {
+	enumerable: true,
+	get: function() {
+		return _formatRelativeTimeFromDate;
+	}
+});
+Object.defineProperty(exports, "_getLocaleDirection", {
+	enumerable: true,
+	get: function() {
+		return _getLocaleDirection;
+	}
+});
+Object.defineProperty(exports, "_getLocaleEmoji", {
+	enumerable: true,
+	get: function() {
+		return _getLocaleEmoji;
+	}
+});
+Object.defineProperty(exports, "_getLocaleName", {
+	enumerable: true,
+	get: function() {
+		return _getLocaleName;
+	}
+});
+Object.defineProperty(exports, "_getLocaleProperties", {
+	enumerable: true,
+	get: function() {
+		return _getLocaleProperties;
+	}
+});
+Object.defineProperty(exports, "_isSameDialect", {
+	enumerable: true,
+	get: function() {
+		return _isSameDialect;
+	}
+});
+Object.defineProperty(exports, "_isSameLanguage", {
+	enumerable: true,
+	get: function() {
+		return _isSameLanguage;
+	}
+});
+Object.defineProperty(exports, "_isSupersetLocale", {
+	enumerable: true,
+	get: function() {
+		return _isSupersetLocale;
+	}
+});
+Object.defineProperty(exports, "_isValidLocale", {
+	enumerable: true,
+	get: function() {
+		return _isValidLocale;
+	}
+});
+Object.defineProperty(exports, "_requiresTranslation", {
+	enumerable: true,
+	get: function() {
+		return _requiresTranslation;
+	}
+});
+Object.defineProperty(exports, "_resolveAliasLocale", {
+	enumerable: true,
+	get: function() {
+		return _resolveAliasLocale;
+	}
+});
+Object.defineProperty(exports, "_resolveCanonicalLocale", {
+	enumerable: true,
+	get: function() {
+		return _resolveCanonicalLocale;
+	}
+});
+Object.defineProperty(exports, "_standardizeLocale", {
+	enumerable: true,
+	get: function() {
+		return _standardizeLocale;
+	}
+});
+Object.defineProperty(exports, "defaultEmoji", {
+	enumerable: true,
+	get: function() {
+		return defaultEmoji;
+	}
+});
+Object.defineProperty(exports, "emojis", {
+	enumerable: true,
+	get: function() {
+		return emojis;
+	}
+});
+Object.defineProperty(exports, "fetchLogger", {
+	enumerable: true,
+	get: function() {
+		return fetchLogger;
+	}
+});
+Object.defineProperty(exports, "formatCutoff", {
+	enumerable: true,
+	get: function() {
+		return formatCutoff;
+	}
+});
+Object.defineProperty(exports, "formatMessage", {
+	enumerable: true,
+	get: function() {
+		return formatMessage;
+	}
+});
+Object.defineProperty(exports, "gtInstanceLogger", {
+	enumerable: true,
+	get: function() {
+		return gtInstanceLogger;
+	}
+});
+Object.defineProperty(exports, "isValidLocale", {
+	enumerable: true,
+	get: function() {
+		return isValidLocale;
+	}
+});
+Object.defineProperty(exports, "resolveCanonicalLocale", {
+	enumerable: true,
+	get: function() {
+		return resolveCanonicalLocale;
+	}
+});
+Object.defineProperty(exports, "standardizeLocale", {
+	enumerable: true,
+	get: function() {
+		return standardizeLocale;
+	}
+});
+
+//# sourceMappingURL=core-LS3Pia40.cjs.map