generaltranslation 8.2.6 → 8.2.8

package/dist/index.mjs

@@ -0,0 +1,3441 @@
+import { B as intlCache, M as encode, V as defaultTimeout, j as decode, k as validateFileFormatTransforms } from "./internal-B3QbyI_5.mjs";
+import { t as ApiError } from "./ApiError-Bv7vlzyQ.mjs";
+import { n as hashSource } from "./id-CPbVYREY.mjs";
+import IntlMessageFormat from "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 } = intlCache.get("Locale", locale);
+		if (locale.split("-").length !== (() => {
+			let partCount = 1;
+			if (region) partCount += 1;
+			if (script) partCount += 1;
+			return partCount;
+		})()) return false;
+		if (intlCache.get("DisplayNames", ["en"], { type: "language" }).of(language) === language && !isCustomLanguage(language)) return false;
+		if (region) {
+			if (intlCache.get("DisplayNames", ["en"], { type: "region" }).of(region) === region) return false;
+		}
+		if (script) {
+			if (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 } = intlCache.get("Locale", codeA);
+	const { language: languageB, region: regionB, script: scriptB } = 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) => 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 = 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 = 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 = intlCache.get("DisplayNames", defaultLanguageOrder, { type: "language" });
+		const nativeLanguageNames = 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 = intlCache.get("DisplayNames", defaultLanguageOrder, { type: "region" });
+		const nativeRegionNames = intlCache.get("DisplayNames", nativeLanguageOrder, { type: "region" });
+		const regionName = customLocaleProperties?.regionName || (regionCode ? regionNames.of(regionCode) : "") || "";
+		const nativeRegionName = customLocaleProperties?.nativeRegionName || (regionCode ? nativeRegionNames.of(regionCode) : "") || "";
+		const scriptNames = intlCache.get("DisplayNames", defaultLanguageOrder, { type: "script" });
+		const nativeScriptNames = 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 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 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 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 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 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 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 = 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 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,
+			intlCache.get("Locale", standardizedLocale).language
+		]) {
+			const customName = getCustomProperty(customMapping, l, "name");
+			if (customName) return customName;
+		}
+		return 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(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 } = intlCache.get("Locale", _standardizeLocale(superLocale));
+		const { language: languageSub, region: regionSub, script: scriptSub } = 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/logging/errors.ts
+const GT_ERROR_PREFIX = "GT Error:";
+const translationTimeoutError = (timeout) => `${GT_ERROR_PREFIX} Translation request timed out after ${timeout}ms.`;
+const translationRequestFailedError = (error) => `${GT_ERROR_PREFIX} Translation request failed. Error: ${error}`;
+const apiError = (status, statusText, error) => `${GT_ERROR_PREFIX} API returned error status. Status: ${status}, Status Text: ${statusText}, Error: ${error}`;
+`${GT_ERROR_PREFIX}`;
+const noTargetLocaleProvidedError = (functionName) => `${GT_ERROR_PREFIX} Cannot call \`${functionName}\` without a specified locale. Either pass a locale to the \`${functionName}\` function or specify a targetLocale in the GT constructor.`;
+const noSourceLocaleProvidedError = (functionName) => `${GT_ERROR_PREFIX} Cannot call \`${functionName}\` without a specified locale. Either pass a locale to the \`${functionName}\` function or specify a sourceLocale in the GT constructor.`;
+const noProjectIdProvidedError = (functionName) => `${GT_ERROR_PREFIX} Cannot call \`${functionName}\` without a specified project ID. Either pass a project ID to the \`${functionName}\` function or specify a projectId in the GT constructor.`;
+const noApiKeyProvidedError = (functionName) => `${GT_ERROR_PREFIX} Cannot call \`${functionName}\` without a specified API key. Either pass an API key to the \`${functionName}\` function or specify an apiKey in the GT constructor.`;
+const invalidLocaleError = (locale) => `${GT_ERROR_PREFIX} Invalid locale: ${locale}.`;
+const invalidLocalesError = (locales) => `${GT_ERROR_PREFIX} Invalid locales: ${locales.join(", ")}.`;
+//#endregion
+//#region src/translate/utils/fetchWithTimeout.ts
+/**
+* @internal
+*
+* Wraps the fetch function with a timeout.
+*
+* @param url - The URL to fetch.
+* @param options - The options to pass to the fetch function.
+* @param timeout - The timeout in milliseconds.
+* @returns The response from the fetch function.
+*/
+async function fetchWithTimeout(url, options, timeout) {
+	const controller = new AbortController();
+	const signal = controller.signal;
+	timeout = timeout ? timeout : defaultTimeout;
+	const timeoutId = timeout ? setTimeout(() => controller.abort(), timeout) : null;
+	try {
+		return await fetch(url, {
+			...options,
+			signal
+		});
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") throw translationTimeoutError(timeout);
+		throw error;
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+}
+//#endregion
+//#region src/translate/utils/validateResponse.ts
+async function validateResponse(response) {
+	if (!response.ok) {
+		let errorMsg = "Unknown error";
+		try {
+			const text = await response.text();
+			try {
+				errorMsg = JSON.parse(text).error;
+			} catch {
+				errorMsg = text || "Unknown error";
+			}
+		} catch {}
+		throw new ApiError(apiError(response.status, response.statusText, errorMsg), response.status, errorMsg);
+	}
+}
+//#endregion
+//#region src/translate/utils/handleFetchError.ts
+function handleFetchError(error, timeout) {
+	if (error instanceof Error && error.name === "AbortError") {
+		const errorMessage = translationTimeoutError(timeout);
+		fetchLogger.error(errorMessage);
+		throw new Error(errorMessage);
+	}
+	const errorMessage = translationRequestFailedError(error instanceof Error ? error.message : String(error));
+	fetchLogger.error(errorMessage);
+	throw error;
+}
+//#endregion
+//#region src/translate/api.ts
+const API_VERSION$1 = "2026-03-06.v1";
+//#endregion
+//#region src/translate/utils/generateRequestHeaders.ts
+function generateRequestHeaders(config, excludeContentType = false) {
+	const authHeaders = {
+		...!excludeContentType && { "Content-Type": "application/json" },
+		"x-gt-project-id": config.projectId
+	};
+	if (config.apiKey) if (config.apiKey.startsWith("gtx-internal-")) authHeaders["x-gt-internal-api-key"] = config.apiKey;
+	else authHeaders["x-gt-api-key"] = config.apiKey;
+	authHeaders["gt-api-version"] = API_VERSION$1;
+	return authHeaders;
+}
+//#endregion
+//#region src/translate/utils/apiRequest.ts
+const MAX_RETRIES = 3;
+const INITIAL_DELAY_MS = 500;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getRetryDelay(policy, attempt) {
+	switch (policy) {
+		case "linear": return INITIAL_DELAY_MS * (attempt + 1);
+		case "exponential": return INITIAL_DELAY_MS * 2 ** attempt;
+		default: return 0;
+	}
+}
+/**
+* @internal
+*
+* Makes an API request with automatic retry for 5XX errors.
+*
+* Encapsulates URL construction, fetch with timeout, error handling,
+* response validation, and JSON parsing.
+*
+* @param config - The configuration for the API call
+* @param endpoint - The API endpoint path (e.g. '/v2/project/jobs/info')
+* @param options - Optional request options
+* @returns The parsed JSON response
+*/
+async function apiRequest(config, endpoint, options) {
+	const timeout = options?.timeout ?? 6e4;
+	const url = `${config.baseUrl || "https://api2.gtx.dev"}${endpoint}`;
+	const method = options?.method ?? "POST";
+	const retryPolicy = options?.retryPolicy ?? "exponential";
+	const maxRetries = retryPolicy === "none" ? 0 : MAX_RETRIES;
+	const requestInit = {
+		method,
+		headers: generateRequestHeaders(config)
+	};
+	if (options?.body !== void 0) requestInit.body = JSON.stringify(options.body);
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		let response;
+		try {
+			response = await fetchWithTimeout(url, requestInit, timeout);
+		} catch (error) {
+			if (attempt < maxRetries) {
+				await sleep(getRetryDelay(retryPolicy, attempt));
+				continue;
+			}
+			handleFetchError(error, timeout);
+		}
+		if (response.status >= 500 && attempt < maxRetries) {
+			await sleep(getRetryDelay(retryPolicy, attempt));
+			continue;
+		}
+		await validateResponse(response);
+		return await response.json();
+	}
+	throw new Error("Max retries exceeded");
+}
+//#endregion
+//#region src/translate/translateMany.ts
+async function _translateMany(requests, globalMetadata, config, timeout) {
+	const isArray = Array.isArray(requests);
+	const hashOrder = isArray ? [] : void 0;
+	const requestsObject = {};
+	const entries = isArray ? requests.map((r) => [void 0, r]) : Object.entries(requests);
+	for (const [key, request] of entries) {
+		const { source, metadata } = typeof request === "string" ? { source: request } : request;
+		const hash = key ?? metadata?.hash ?? hashSource({
+			source,
+			dataFormat: metadata?.dataFormat ?? "STRING",
+			...metadata ?? {}
+		});
+		hashOrder?.push(hash);
+		requestsObject[hash] = {
+			source,
+			metadata
+		};
+	}
+	const response = await apiRequest({
+		...config,
+		baseUrl: config.baseUrl || "https://runtime2.gtx.dev"
+	}, `/v2/translate`, {
+		body: {
+			requests: requestsObject,
+			targetLocale: globalMetadata.targetLocale,
+			sourceLocale: globalMetadata.sourceLocale,
+			metadata: globalMetadata
+		},
+		timeout,
+		retryPolicy: "none"
+	});
+	if (hashOrder) return hashOrder.map((hash) => response[hash] ?? {
+		success: false,
+		error: "No translation returned",
+		code: 500
+	});
+	return response;
+}
+//#endregion
+//#region src/translate/setupProject.ts
+/**
+* @internal
+* Enqueues files for project setup the General Translation API.
+* @param files - References of files to translate (file content already uploaded)
+* @param config - The configuration for the API call
+* @param timeoutMS - The timeout in milliseconds
+* @returns The result of the API call
+*/
+async function _setupProject(files, config, options) {
+	return apiRequest(config, "/v2/project/setup/generate", {
+		body: {
+			files: files.map((f) => ({
+				branchId: f.branchId,
+				fileId: f.fileId,
+				versionId: f.versionId
+			})),
+			locales: options?.locales,
+			force: options?.force
+		},
+		timeout: options?.timeoutMs
+	});
+}
+//#endregion
+//#region src/translate/utils/batch.ts
+/**
+* Splits an array into batches of a specified size.
+* @param items - The array to split into batches
+* @param batchSize - The maximum size of each batch
+* @returns An array of batches
+*/
+function createBatches(items, batchSize) {
+	const batches = [];
+	for (let i = 0; i < items.length; i += batchSize) batches.push(items.slice(i, i + batchSize));
+	return batches;
+}
+/**
+* Processes items in batches using a provided processor function.
+*
+* @param items - The items to process
+* @param processor - Async function that processes a single batch and returns items
+* @param options - Optional configuration for batch processing
+* @returns Promise that resolves to a BatchList containing all processed items
+*
+* @example
+* ```typescript
+* const result = await processBatches(
+*   files,
+*   async (batch) => {
+*     const response = await uploadFiles(batch);
+*     return response.uploadedFiles;
+*   },
+*   { batchSize: 100 }
+* );
+*
+* console.log(result.data); // All items
+* console.log(result.count); // Total count
+* console.log(result.batchCount); // Number of batches processed
+* ```
+*/
+async function processBatches(items, processor, options = {}) {
+	const { batchSize = 100, parallel = true } = options;
+	if (items.length === 0) return {
+		data: [],
+		count: 0,
+		batchCount: 0
+	};
+	const batches = createBatches(items, batchSize);
+	const allItems = [];
+	if (parallel) {
+		const results = await Promise.all(batches.map((batch) => processor(batch)));
+		for (const result of results) if (result) allItems.push(...result);
+	} else for (const batch of batches) {
+		const result = await processor(batch);
+		if (result) allItems.push(...result);
+	}
+	return {
+		data: allItems,
+		count: allItems.length,
+		batchCount: batches.length
+	};
+}
+//#endregion
+//#region src/translate/enqueueFiles.ts
+/**
+* @internal
+* Enqueues files for translation in the General Translation API.
+* @param files - References of files to translate (file content already uploaded)
+* @param options - The options for the API call
+* @param config - The configuration for the API call
+* @returns The result of the API call
+*/
+async function _enqueueFiles(files, options, config) {
+	validateFileFormatTransforms(files);
+	const result = await processBatches(files, async (batch) => {
+		const apiResult = await apiRequest(config, "/v2/project/translations/enqueue", {
+			body: {
+				files: batch.map((f) => ({
+					branchId: f.branchId,
+					fileId: f.fileId,
+					versionId: f.versionId,
+					fileName: f.fileName,
+					transformFormat: f.transformFormat
+				})),
+				targetLocales: options.targetLocales,
+				sourceLocale: options.sourceLocale,
+				requireApproval: options.requireApproval,
+				modelProvider: options.modelProvider,
+				force: options.force
+			},
+			timeout: options.timeout
+		});
+		return Array.from(Object.entries(apiResult.jobData));
+	}, { batchSize: 100 });
+	return {
+		jobData: Object.fromEntries(result.data.map(([jobId, jobData]) => [jobId, jobData])),
+		locales: options.targetLocales,
+		message: `Successfully enqueued ${result.count} file translation jobs in ${result.batchCount} batch(es)`
+	};
+}
+//#endregion
+//#region src/translate/createTag.ts
+/**
+* @internal
+* Creates or upserts a file tag in the General Translation API.
+* @param options - The tag creation options
+* @param config - The configuration for the API call
+* @returns The created or updated tag
+*/
+async function _createTag(options, config) {
+	return await apiRequest(config, "/v2/project/tags/create", { body: {
+		tagId: options.tagId,
+		files: options.files,
+		...options.message && { message: options.message }
+	} });
+}
+//#endregion
+//#region src/translate/downloadFileBatch.ts
+/**
+* @internal
+* Downloads multiple translation files in batches.
+* @param files - Array of files to download
+* @param options - The options for the API call
+* @param config - The configuration for the request
+* @returns Promise resolving to a BatchList with all downloaded files
+*/
+async function _downloadFileBatch(requests, options, config) {
+	return processBatches(requests, async (batch) => {
+		return (await apiRequest(config, "/v2/project/files/download", {
+			body: batch,
+			timeout: options.timeout
+		})).files.map((file) => ({
+			...file,
+			data: decode(file.data)
+		}));
+	}, { batchSize: 100 });
+}
+//#endregion
+//#region src/translate/submitUserEditDiffs.ts
+/**
+* @internal
+* Submits user edit diffs so the service can learn/persist user-intended rules.
+*/
+async function _submitUserEditDiffs(payload, config, options = {}) {
+	await processBatches(payload.diffs, async (batch) => {
+		await apiRequest(config, "/v2/project/files/diffs", {
+			body: { diffs: batch },
+			timeout: options.timeout
+		});
+		return [{ success: true }];
+	}, { batchSize: 100 });
+	return { success: true };
+}
+//#endregion
+//#region src/locales/getRegionProperties.ts
+/**
+* Retrieves multiple properties for a given region code, including:
+* - `code`: the original region code
+* - `name`: the localized display name
+* - `emoji`: the associated flag or symbol
+*
+* Behavior:
+* - Accepts ISO 3166-1 alpha-2 or UN M.49 region codes (e.g., `"US"`, `"FR"`, `"419"`).
+* - If `customMapping` contains a `name` or `emoji` for the region, those override the default values.
+* - Otherwise, uses `Intl.DisplayNames` to get the localized region name in the given `defaultLocale`,
+*   falling back to `libraryDefaultLocale`.
+* - Falls back to the region code as `name` if display name resolution fails.
+* - Falls back to `defaultEmoji` if no emoji mapping is found in `emojis` or `customMapping`.
+*
+* @param {string} region - The region code to look up (e.g., `"US"`, `"GB"`, `"DE"`).
+* @param {string} [defaultLocale=libraryDefaultLocale] - The locale to use when localizing the region name.
+* @param {CustomRegionMapping} [customMapping] - Optional mapping of region codes to custom names and/or emojis.
+* @returns {{ code: string, name: string, emoji: string }} An object containing:
+*  - `code`: the input region code
+*  - `name`: the localized or custom region name
+*  - `emoji`: the matching emoji flag or symbol
+* @internal
+*
+* @example
+* _getRegionProperties('US', 'en');
+* // => { code: 'US', name: 'United States', emoji: '🇺🇸' }
+*
+* @example
+* _getRegionProperties('US', 'fr');
+* // => { code: 'US', name: 'États-Unis', emoji: '🇺🇸' }
+*
+* @example
+* _getRegionProperties('US', 'en', { US: { name: 'USA', emoji: '🗽' } });
+* // => { code: 'US', name: 'USA', emoji: '🗽' }
+*/
+function _getRegionProperties(region, defaultLocale = "en", customMapping) {
+	defaultLocale ||= "en";
+	try {
+		return {
+			code: region,
+			name: intlCache.get("DisplayNames", [defaultLocale, "en"], { type: "region" }).of(region) || region,
+			emoji: emojis[region] || "🌍",
+			...customMapping?.[region]
+		};
+	} catch {
+		return {
+			code: region,
+			name: region,
+			emoji: defaultEmoji,
+			...customMapping?.[region]
+		};
+	}
+}
+//#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/translate/uploadSourceFiles.ts
+/**
+* @internal
+* Uploads source files to the General Translation API in batches.
+* @param files - The files to upload
+* @param options - The options for the API call
+* @param config - The configuration for the API call
+* @returns Promise resolving to a BatchList with all uploaded files
+*/
+async function _uploadSourceFiles(files, options, config) {
+	return processBatches(files, async (batch) => {
+		return (await apiRequest(config, "/v2/project/files/upload-files", {
+			body: {
+				data: batch.map(({ source }) => ({ source: {
+					content: encode(source.content),
+					fileName: source.fileName,
+					fileFormat: source.fileFormat,
+					locale: source.locale,
+					dataFormat: source.dataFormat,
+					formatMetadata: source.formatMetadata,
+					fileId: source.fileId,
+					versionId: source.versionId,
+					branchId: source.branchId,
+					incomingBranchId: source.incomingBranchId,
+					checkedOutBranchId: source.checkedOutBranchId
+				} })),
+				sourceLocale: options.sourceLocale
+			},
+			timeout: options.timeout
+		})).uploadedFiles || [];
+	}, { batchSize: 100 });
+}
+//#endregion
+//#region src/translate/uploadTranslations.ts
+/**
+* @internal
+* Uploads multiple translations to the General Translation API in batches.
+* @param files - Translations to upload with their source
+* @param options - The options for the API call
+* @param config - The configuration for the API call
+* @returns Promise resolving to a BatchList with all uploaded files
+*/
+async function _uploadTranslations(files, options, config) {
+	validateFileFormatTransforms(files.map(({ source }) => source));
+	return processBatches(files, async (batch) => {
+		return (await apiRequest(config, "/v2/project/files/upload-translations", {
+			body: {
+				data: batch.map(({ source, translations }) => ({
+					source: {
+						content: encode(source.content),
+						fileName: source.fileName,
+						fileFormat: source.fileFormat,
+						transformFormat: source.transformFormat,
+						locale: source.locale,
+						dataFormat: source.dataFormat,
+						formatMetadata: source.formatMetadata,
+						fileId: source.fileId,
+						versionId: source.versionId,
+						branchId: source.branchId
+					},
+					translations: translations.map((t) => ({
+						content: encode(t.content),
+						fileName: t.fileName,
+						fileFormat: t.fileFormat,
+						locale: t.locale,
+						dataFormat: t.dataFormat,
+						fileId: t.fileId,
+						versionId: t.versionId,
+						branchId: t.branchId
+					}))
+				})),
+				sourceLocale: options.sourceLocale
+			},
+			timeout: options.timeout
+		})).uploadedFiles || [];
+	}, { batchSize: 100 });
+}
+//#endregion
+//#region src/translate/querySourceFile.ts
+/**
+* @internal
+* Gets the source file and translation information for a given file ID and version ID.
+* @param query - The file ID and version ID to get the source file and translation information for
+* @param options - The options for the API call
+* @param config - The configuration for the request
+* @returns The source file and translation information for the given file ID and version ID
+*/
+async function _querySourceFile(query, options, config) {
+	const branchId = query.branchId;
+	const versionId = query.versionId;
+	const fileId = query.fileId;
+	const searchParams = new URLSearchParams();
+	if (branchId) searchParams.set("branchId", branchId);
+	if (versionId) searchParams.set("versionId", versionId);
+	return apiRequest(config, `/v2/project/translations/files/status/${encodeURIComponent(fileId)}?${searchParams.toString()}`, {
+		method: "GET",
+		timeout: options.timeout
+	});
+}
+//#endregion
+//#region src/projects/getProjectData.ts
+/**
+* @internal
+* Gets the project data for a given project ID.
+* @param projectId - The project ID to get the project data for
+* @param options - The options for the API call
+* @param config - The configuration for the request
+* @returns The project data for the given project ID
+*/
+async function _getProjectData(projectId, options, config) {
+	const { baseUrl } = config;
+	const timeout = options.timeout ? options.timeout : defaultTimeout;
+	const url = `${baseUrl || "https://api2.gtx.dev"}/v2/project/info/${encodeURIComponent(projectId)}`;
+	let response;
+	try {
+		response = await fetchWithTimeout(url, {
+			method: "GET",
+			headers: generateRequestHeaders(config)
+		}, timeout);
+	} catch (error) {
+		handleFetchError(error, timeout);
+	}
+	await validateResponse(response);
+	return await response.json();
+}
+//#endregion
+//#region src/translate/checkJobStatus.ts
+/**
+* @internal
+* Queries job statuses for a project
+* @param jobIds - Job IDs
+* @param config - The configuration for the API call
+* @param timeoutMS - The timeout in milliseconds
+* @returns The result of the API call
+*/
+async function _checkJobStatus(jobIds, config, timeoutMs) {
+	return apiRequest(config, "/v2/project/jobs/info", {
+		body: { jobIds },
+		timeout: timeoutMs
+	});
+}
+//#endregion
+//#region src/translate/awaitJobs.ts
+/**
+* @internal
+* Polls job statuses until all jobs are finished or the timeout is reached.
+* @param enqueueResult - The result from enqueueFiles
+* @param options - Polling configuration
+* @param config - API credentials and configuration
+* @returns The final status of all jobs
+*/
+async function _awaitJobs(enqueueResult, options, config) {
+	const pollingInterval = (options?.pollingIntervalSeconds ?? 5) * 1e3;
+	const timeout = options?.timeoutSeconds !== void 0 ? options.timeoutSeconds * 1e3 : 600 * 1e3;
+	const jobIds = Object.keys(enqueueResult.jobData);
+	if (jobIds.length === 0) return {
+		complete: true,
+		jobs: []
+	};
+	const startTime = Date.now();
+	const finalStatuses = new Map(jobIds.map((id) => [id, {
+		jobId: id,
+		status: "unknown"
+	}]));
+	const pendingJobIds = new Set(jobIds);
+	while (pendingJobIds.size > 0) {
+		const statuses = await _checkJobStatus(Array.from(pendingJobIds), config);
+		for (const job of statuses) if (job.status === "completed" || job.status === "failed" || job.status === "unknown") {
+			finalStatuses.set(job.jobId, {
+				jobId: job.jobId,
+				status: job.status,
+				...job.error ? { error: job.error } : {}
+			});
+			pendingJobIds.delete(job.jobId);
+		} else finalStatuses.set(job.jobId, {
+			jobId: job.jobId,
+			status: job.status
+		});
+		if (pendingJobIds.size === 0) break;
+		if (Date.now() - startTime >= timeout) break;
+		await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+	}
+	return {
+		complete: pendingJobIds.size === 0,
+		jobs: Array.from(finalStatuses.values())
+	};
+}
+//#endregion
+//#region src/translate/queryFileData.ts
+/**
+* @internal
+* Queries data about one or more source or translation files.
+* @param data - Object mapping source or translation file information
+* @param options - The options for the API call
+* @param config - The configuration for the API call
+* @returns The file data
+*/
+async function _queryFileData(data, options = {}, config) {
+	return apiRequest(config, "/v2/project/files/info", {
+		body: {
+			sourceFiles: data.sourceFiles?.map((item) => ({
+				fileId: item.fileId,
+				versionId: item.versionId,
+				branchId: item.branchId
+			})),
+			translatedFiles: data.translatedFiles?.map((item) => ({
+				fileId: item.fileId,
+				versionId: item.versionId,
+				branchId: item.branchId,
+				locale: item.locale
+			}))
+		},
+		timeout: options.timeout
+	});
+}
+//#endregion
+//#region src/translate/queryBranchData.ts
+/**
+* @internal
+* Queries branch information from the API.
+* @param query - Object mapping the current branch and incoming branches
+* @param config - The configuration for the API call
+* @returns The branch information
+*/
+async function _queryBranchData(query, config) {
+	return apiRequest(config, "/v2/project/branches/info", { body: query });
+}
+//#endregion
+//#region src/translate/createBranch.ts
+/**
+* @internal
+* Creates a new branch in the API.
+* @param query - Object mapping the branch name and default branch flag
+* @param config - The configuration for the API call
+* @returns The created branch information
+*/
+async function _createBranch(query, config) {
+	return apiRequest(config, "/v2/project/branches/create", { body: query });
+}
+//#endregion
+//#region src/translate/processFileMoves.ts
+/**
+* @internal
+* Processes file moves by cloning source files and translations with new fileIds.
+* Called when the CLI detects that files have been moved/renamed.
+* @param moves - Array of move mappings (old fileId to new fileId)
+* @param options - Options including branchId and timeout
+* @param config - The configuration for the API call
+* @returns Promise resolving to the move results
+*/
+async function _processFileMoves(moves, options, config) {
+	if (moves.length === 0) return {
+		results: [],
+		summary: {
+			total: 0,
+			succeeded: 0,
+			failed: 0
+		}
+	};
+	const batchResult = await processBatches(moves, async (batch) => {
+		return (await apiRequest(config, "/v2/project/files/moves", {
+			body: {
+				branchId: options.branchId,
+				moves: batch
+			},
+			timeout: options.timeout
+		})).results;
+	}, { batchSize: 100 });
+	const succeeded = batchResult.data.filter((r) => r.success).length;
+	const failed = batchResult.data.filter((r) => !r.success).length;
+	return {
+		results: batchResult.data,
+		summary: {
+			total: moves.length,
+			succeeded,
+			failed
+		}
+	};
+}
+//#endregion
+//#region src/translate/getOrphanedFiles.ts
+/**
+* @internal
+* Gets orphaned files for a branch - files that exist on the branch
+* but whose fileIds are not in the provided list.
+* Used for move detection.
+* @param branchId - The branch to check for orphaned files
+* @param fileIds - List of current file IDs (files that are NOT orphaned)
+* @param options - The options for the API call
+* @param config - The configuration for the API call
+* @returns The orphaned files
+*/
+async function _getOrphanedFiles(branchId, fileIds, options = {}, config) {
+	const makeRequest = (batchFileIds) => apiRequest(config, "/v2/project/files/orphaned", {
+		body: {
+			branchId,
+			fileIds: batchFileIds
+		},
+		timeout: options.timeout
+	});
+	if (fileIds.length === 0) return makeRequest([]);
+	const batches = createBatches(fileIds, 100);
+	const batchResults = await Promise.all(batches.map((batch) => makeRequest(batch)));
+	if (batchResults.length === 1) return batchResults[0];
+	const orphanedFileMap = /* @__PURE__ */ new Map();
+	for (const orphan of batchResults[0].orphanedFiles) orphanedFileMap.set(orphan.fileId, orphan);
+	for (let i = 1; i < batchResults.length; i++) {
+		const batchOrphanIds = new Set(batchResults[i].orphanedFiles.map((f) => f.fileId));
+		Array.from(orphanedFileMap.keys()).forEach((fileId) => {
+			if (!batchOrphanIds.has(fileId)) orphanedFileMap.delete(fileId);
+		});
+	}
+	return { orphanedFiles: Array.from(orphanedFileMap.values()) };
+}
+//#endregion
+//#region src/translate/publishFiles.ts
+/**
+* @internal
+* Publishes or unpublishes files on the CDN.
+* @param files - Array of file entries with publish flags
+* @param config - The configuration for the API call
+* @returns The result of the API call
+*/
+async function _publishFiles(files, config) {
+	return await apiRequest(config, "/v2/project/files/publish", { body: { files } });
+}
+//#endregion
+//#region src/LocaleConfig.ts
+/**
+* LocaleConfig is a client-safe locale and formatting helper.
+*
+* 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/index.ts
+/**
+* GT is the core driver for the General Translation library.
+* This class provides functionality for locale management, formatting, and translation operations.
+*
+* @class GT
+* @description A comprehensive toolkit for handling internationalization and localization.
+*
+* @example
+* const gt = new GT({
+*   sourceLocale: 'en-US',
+*   targetLocale: 'es-ES',
+*   locales: ['en-US', 'es-ES', 'fr-FR']
+* });
+*/
+var GT = class {
+	/** Client-safe locale and formatting helpers */
+	get localeConfig() {
+		return this._localeConfig;
+	}
+	/**
+	* Constructs an instance of the GT class.
+	*
+	* @param {GTConstructorParams} [params] - The parameters for initializing the GT instance
+	* @throws {Error} If an invalid locale is provided
+	* @throws {Error} If any of the provided locales are invalid
+	*
+	* @example
+	* const gt = new GT({
+	*   apiKey: 'your-api-key',
+	*   sourceLocale: 'en-US',
+	*   targetLocale: 'es-ES',
+	*   locales: ['en-US', 'es-ES', 'fr-FR']
+	* });
+	*/
+	constructor(params = {}) {
+		if (typeof process !== "undefined") {
+			this.apiKey ||= process.env?.GT_API_KEY;
+			this.devApiKey ||= process.env?.GT_DEV_API_KEY;
+			this.projectId ||= process.env?.GT_PROJECT_ID;
+		}
+		this.setConfig(params);
+	}
+	setConfig({ apiKey, devApiKey, sourceLocale, targetLocale, locales, projectId, customMapping, baseUrl }) {
+		if (apiKey) this.apiKey = apiKey;
+		if (devApiKey) this.devApiKey = devApiKey;
+		if (projectId) this.projectId = projectId;
+		if (sourceLocale) {
+			this.sourceLocale = _standardizeLocale(sourceLocale);
+			if (!_isValidLocale(this.sourceLocale, customMapping)) throw new Error(invalidLocaleError(this.sourceLocale));
+		}
+		if (targetLocale) {
+			this.targetLocale = _standardizeLocale(targetLocale);
+			if (!_isValidLocale(this.targetLocale, customMapping)) throw new Error(invalidLocaleError(this.targetLocale));
+		}
+		if (locales) {
+			const result = [];
+			const invalidLocales = [];
+			locales.forEach((locale) => {
+				const standardizedLocale = _standardizeLocale(locale);
+				if (_isValidLocale(standardizedLocale)) result.push(standardizedLocale);
+				else invalidLocales.push(locale);
+			});
+			if (invalidLocales.length > 0) throw new Error(invalidLocalesError(invalidLocales));
+			this.locales = result;
+		}
+		if (baseUrl) this.baseUrl = baseUrl;
+		if (customMapping) {
+			this.customMapping = customMapping;
+			this.reverseCustomMapping = Object.fromEntries(Object.entries(customMapping).filter(([, value]) => value && typeof value === "object" && "code" in value).map(([key, value]) => [value.code, key]));
+		}
+		this._localeConfig = new LocaleConfig({
+			defaultLocale: this.sourceLocale,
+			locales: this.locales ?? [],
+			customMapping: this.customMapping
+		});
+	}
+	_getTranslationConfig() {
+		return {
+			baseUrl: this.baseUrl,
+			apiKey: this.apiKey || this.devApiKey,
+			projectId: this.projectId || ""
+		};
+	}
+	_validateAuth(functionName) {
+		const errors = [];
+		if (!this.apiKey && !this.devApiKey) {
+			const error = noApiKeyProvidedError(functionName);
+			errors.push(error);
+		}
+		if (!this.projectId) {
+			const error = noProjectIdProvidedError(functionName);
+			errors.push(error);
+		}
+		if (errors.length) throw new Error(errors.join("\n"));
+	}
+	/**
+	* Queries branch information from the API.
+	*
+	* @param {BranchQuery} query - Object mapping the current branch and incoming branches
+	* @returns {Promise<BranchDataResult>} The branch information
+	*/
+	async queryBranchData(query) {
+		this._validateAuth("queryBranchData");
+		return await _queryBranchData(query, this._getTranslationConfig());
+	}
+	/**
+	* Creates a new branch in the API. If the branch already exists, it will be returned.
+	*
+	* @param {CreateBranchQuery} query - Object mapping the branch name and default branch flag
+	* @returns {Promise<CreateBranchResult>} The created branch information
+	*/
+	async createBranch(query) {
+		this._validateAuth("createBranch");
+		return await _createBranch(query, this._getTranslationConfig());
+	}
+	/**
+	* Processes file moves by cloning source files and translations with new fileIds.
+	* This is called when files have been moved/renamed and we want to preserve translations.
+	*
+	* @param {MoveMapping[]} moves - Array of move mappings (old fileId to new fileId)
+	* @param {ProcessMovesOptions} options - Options including branchId and timeout
+	* @returns {Promise<ProcessMovesResponse>} The move processing results
+	*
+	* @example
+	* const result = await gt.processFileMoves([
+	*   { oldFileId: 'abc123', newFileId: 'def456', newFileName: 'locales/en.json' }
+	* ], { branchId: 'main' });
+	*/
+	async processFileMoves(moves, options = {}) {
+		this._validateAuth("processFileMoves");
+		return await _processFileMoves(moves, options, this._getTranslationConfig());
+	}
+	/**
+	* Gets orphaned files for a branch - files that exist on the branch
+	* but whose fileIds are not in the provided list.
+	* Used for move detection.
+	*
+	* @param {string} branchId - The branch to check for orphaned files
+	* @param {string[]} fileIds - List of current file IDs (files that are NOT orphaned)
+	* @param {Object} options - Options including timeout
+	* @returns {Promise<GetOrphanedFilesResult>} The orphaned files
+	*
+	* @example
+	* const result = await gt.getOrphanedFiles('branch-id', ['file-1', 'file-2']);
+	*/
+	async getOrphanedFiles(branchId, fileIds, options = {}) {
+		this._validateAuth("getOrphanedFiles");
+		return await _getOrphanedFiles(branchId, fileIds, options, this._getTranslationConfig());
+	}
+	/**
+	* Enqueues project setup job using the specified file references
+	*
+	* This method creates setup jobs that will process source file references
+	* and generate a project setup. The files parameter contains references (IDs) to source
+	* files that have already been uploaded via uploadSourceFiles. The setup jobs are queued
+	* for processing and will generate a project setup based on the source files.
+	*
+	* @param {FileReference[]} files - Array of file references containing IDs of previously uploaded source files
+	* @param {SetupProjectOptions} [options] - Optional settings for target locales and timeout
+	* @returns {Promise<SetupProjectResult>} Object containing the jobId and status
+	*/
+	async setupProject(files, options) {
+		this._validateAuth("setupProject");
+		options = {
+			...options,
+			locales: options?.locales?.map((locale) => this.resolveCanonicalLocale(locale))
+		};
+		return await _setupProject(files, this._getTranslationConfig(), options);
+	}
+	/**
+	* Checks the current status of one or more project jobs by their unique identifiers.
+	*
+	* This method polls the API to determine whether one or more jobs are still running,
+	* have completed successfully, or have failed. Jobs are created after calling either enqueueFiles or setupProject.
+	*
+	* @param {string[]} jobIds - The unique identifiers of the jobs to check
+	* @param {number} [timeoutMs] - Optional timeout in milliseconds for the API request
+	* @returns {Promise<CheckJobStatusResult>} Object containing the job status
+	*
+	* @example
+	* const result = await gt.checkJobStatus([
+	*   'job-123',
+	*   'job-456',
+	* ], {
+	*   timeout: 10000,
+	* });
+	*/
+	async checkJobStatus(jobIds, timeoutMs) {
+		this._validateAuth("checkJobStatus");
+		return await _checkJobStatus(jobIds, this._getTranslationConfig(), timeoutMs);
+	}
+	/**
+	* Polls job statuses until all jobs from enqueueFiles are finished or the timeout is reached.
+	*
+	* @param {EnqueueFilesResult} enqueueResult - The result returned from enqueueFiles
+	* @param {AwaitJobsOptions} [options] - Polling configuration (interval, timeout)
+	* @returns {Promise<AwaitJobsResult>} The final status of all jobs and whether they all completed
+	*/
+	async awaitJobs(enqueueResult, options) {
+		this._validateAuth("awaitJobs");
+		return await _awaitJobs(enqueueResult, options, this._getTranslationConfig());
+	}
+	/**
+	* Enqueues translation jobs for previously uploaded source files.
+	*
+	* This method creates translation jobs that will process existing source files
+	* and generate translations in the specified target languages. The files parameter
+	* contains references (IDs) to source files that have already been uploaded via
+	* uploadSourceFiles. The translation jobs are queued for processing and will
+	* generate translated content based on the source files and target locales provided.
+	*
+	* @param {FileReferenceIds[]} files - Array of file references containing IDs of previously uploaded source files
+	* @param {EnqueueOptions} options - Configuration options including source locale, target locales, and job settings
+	* @returns {Promise<EnqueueFilesResult>} Result containing job IDs, queue status, and processing information
+	*/
+	async enqueueFiles(files, options) {
+		this._validateAuth("enqueueFiles");
+		let mergedOptions = {
+			...options,
+			sourceLocale: options.sourceLocale ?? this.sourceLocale,
+			targetLocales: options.targetLocales ?? [this.targetLocale]
+		};
+		if (!mergedOptions.sourceLocale) {
+			const error = noSourceLocaleProvidedError("enqueueFiles");
+			gtInstanceLogger.error(error);
+			throw new Error(error);
+		}
+		if (!mergedOptions.targetLocales || mergedOptions.targetLocales.length === 0) {
+			const error = noTargetLocaleProvidedError("enqueueFiles");
+			gtInstanceLogger.error(error);
+			throw new Error(error);
+		}
+		mergedOptions = {
+			...mergedOptions,
+			targetLocales: mergedOptions.targetLocales.map((locale) => this.resolveCanonicalLocale(locale))
+		};
+		return await _enqueueFiles(files, mergedOptions, this._getTranslationConfig());
+	}
+	/**
+	* Creates or upserts a file tag, associating a set of source files
+	* with a user-defined tag ID and optional message.
+	*
+	* @param {CreateTagOptions} options - Tag creation options including tagId, sourceFileIds, and optional message
+	* @returns {Promise<CreateTagResult>} The created or updated tag
+	*/
+	async createTag(options) {
+		this._validateAuth("createTag");
+		return await _createTag(options, this._getTranslationConfig());
+	}
+	/**
+	* Publishes or unpublishes files on the CDN.
+	*
+	* @param {PublishFileEntry[]} files - Array of file entries with publish flags
+	* @returns {Promise<PublishFilesResult>} Result containing per-file success/failure
+	*/
+	async publishFiles(files) {
+		this._validateAuth("publishFiles");
+		return await _publishFiles(files, this._getTranslationConfig());
+	}
+	/**
+	* Submits user edit diffs for existing translations so future generations preserve user intent.
+	*
+	* @param {SubmitUserEditDiffsPayload} payload - Project-scoped diff payload.
+	* @returns {Promise<void>} Resolves when submission succeeds.
+	*/
+	async submitUserEditDiffs(payload) {
+		this._validateAuth("submitUserEditDiffs");
+		await _submitUserEditDiffs({
+			...payload,
+			diffs: (payload.diffs || []).map((d) => ({
+				...d,
+				locale: this.resolveCanonicalLocale(d.locale)
+			}))
+		}, this._getTranslationConfig());
+	}
+	/**
+	* Queries data about one or more source or translation files.
+	*
+	* @param {FileDataQuery} data - Object mapping source and translation file information.
+	* @param {CheckFileTranslationsOptions} options - Options for the API call.
+	* @returns {Promise<FileDataResult>} The source and translation file data information.
+	*
+	* @example
+	* const result = await gt.queryFileData({
+	*   sourceFiles: [
+	*     { fileId: '1234567890', versionId: '1234567890', branchId: '1234567890' },
+	*   ],
+	*   translatedFiles: [
+	*     { fileId: '1234567890', versionId: '1234567890', branchId: '1234567890', locale: 'es-ES' },
+	*   ],
+	* }, {
+	*   timeout: 10000,
+	* });
+	*
+	*/
+	async queryFileData(data, options = {}) {
+		this._validateAuth("queryFileData");
+		data.translatedFiles = data.translatedFiles?.map((item) => ({
+			...item,
+			locale: this.resolveCanonicalLocale(item.locale)
+		}));
+		const result = await _queryFileData(data, options, this._getTranslationConfig());
+		result.translatedFiles = result.translatedFiles?.map((item) => ({
+			...item,
+			...item.locale && { locale: this.resolveAliasLocale(item.locale) }
+		}));
+		result.sourceFiles = result.sourceFiles?.map((item) => ({
+			...item,
+			...item.sourceLocale && { sourceLocale: this.resolveAliasLocale(item.sourceLocale) },
+			locales: item.locales.map((locale) => this.resolveAliasLocale(locale))
+		}));
+		return result;
+	}
+	/**
+	* Gets source and translation information for a given file ID and version ID.
+	*
+	* @param {FileQuery} data - File query containing file ID and version ID.
+	* @param {CheckFileTranslationsOptions} options - Options for getting source and translation information.
+	* @returns {Promise<FileQueryResult>} The source file and translation information.
+	*
+	* @example
+	* const result = await gt.querySourceFile(
+	*   { fileId: '1234567890', versionId: '1234567890' },
+	*   { timeout: 10000 }
+	* );
+	*
+	*/
+	async querySourceFile(data, options = {}) {
+		this._validateAuth("querySourceFile");
+		const result = await _querySourceFile(data, options, this._getTranslationConfig());
+		result.translations = result.translations.map((item) => ({
+			...item,
+			...item.locale && { locale: this.resolveAliasLocale(item.locale) }
+		}));
+		result.sourceFile.locales = result.sourceFile.locales.map((locale) => this.resolveAliasLocale(locale));
+		if (result.sourceFile.sourceLocale) result.sourceFile.sourceLocale = this.resolveAliasLocale(result.sourceFile.sourceLocale);
+		return result;
+	}
+	/**
+	* Get project data for a given project ID.
+	*
+	* @param {string} projectId - The ID of the project to get the data for.
+	* @returns {Promise<ProjectData>} The project data.
+	*
+	* @example
+	* const result = await gt.getProjectData(
+	*   '1234567890'
+	* );
+	*
+	*/
+	async getProjectData(projectId, options = {}) {
+		this._validateAuth("getProjectData");
+		const result = await _getProjectData(projectId, options, this._getTranslationConfig());
+		result.currentLocales = result.currentLocales.map((item) => this.resolveAliasLocale(item));
+		result.defaultLocale = this.resolveAliasLocale(result.defaultLocale);
+		return result;
+	}
+	/**
+	* Downloads a single file.
+	*
+	* @param file - The file query object.
+	* @param {string} file.fileId - The ID of the file to download.
+	* @param {string} [file.branchId] - The ID of the branch to download the file from. If not provided, the default branch will be used.
+	* @param {string} [file.locale] - The locale to download the file for. If not provided, the source file will be downloaded.
+	* @param {string} [file.versionId] - The version ID to download the file from. If not provided, the latest version will be used.
+	* @param {DownloadFileOptions} options - Options for downloading the file.
+	* @returns {Promise<string>} The downloaded file content.
+	*
+	* @example
+	* const result = await gt.downloadFile({
+	*   fileId: '1234567890',
+	*   branchId: '1234567890',
+	*   locale: 'es-ES',
+	*   versionId: '1234567890',
+	* }, {
+	*   timeout: 10000,
+	* });
+	*/
+	async downloadFile(file, options = {}) {
+		this._validateAuth("downloadTranslatedFile");
+		return (await _downloadFileBatch([{
+			fileId: file.fileId,
+			branchId: file.branchId,
+			locale: file.locale ? this.resolveCanonicalLocale(file.locale) : void 0,
+			versionId: file.versionId,
+			useLatestAvailableVersion: file.useLatestAvailableVersion
+		}], options, this._getTranslationConfig())).data?.[0]?.data ?? "";
+	}
+	/**
+	* Downloads multiple files in a batch.
+	*
+	* @param {DownloadFileBatchRequest} requests - Array of file query objects to download.
+	* @param {DownloadFileBatchOptions} options - Options for the batch download.
+	* @returns {Promise<DownloadFileBatchResult>} The batch download results.
+	*
+	* @example
+	* const result = await gt.downloadFileBatch([{
+	*   fileId: '1234567890',
+	*   locale: 'es-ES',
+	*   versionId: '1234567890',
+	* }], {
+	*   timeout: 10000,
+	* });
+	*/
+	async downloadFileBatch(requests, options = {}) {
+		this._validateAuth("downloadFileBatch");
+		requests = requests.map((request) => ({
+			...request,
+			locale: request.locale ? this.resolveCanonicalLocale(request.locale) : void 0
+		}));
+		const result = await _downloadFileBatch(requests, options, this._getTranslationConfig());
+		return {
+			files: result.data.map((file) => ({
+				...file,
+				...file.locale && { locale: this.resolveAliasLocale(file.locale) }
+			})),
+			count: result.count
+		};
+	}
+	/**
+	* Translates a single source string to the target locale.
+	* Routes through {@link translateMany} under the hood.
+	*
+	* @param {string} source - The source string to translate.
+	* @param {object} options - Translation options including targetLocale and optional entry metadata.
+	* @returns {Promise<TranslationResult | TranslationError>} The translated content.
+	*
+	* @example
+	* const result = await gt.translate('Hello, world!', { targetLocale: 'es' });
+	*
+	* @example
+	* const result = await gt.translate('Hello, world!', {
+	*   targetLocale: 'es',
+	*   dataFormat: 'ICU',
+	*   context: 'A formal greeting',
+	* });
+	*/
+	async translate(source, options, timeout) {
+		if (typeof options === "string") options = { targetLocale: options };
+		this._validateAuth("translate");
+		let targetLocale = options?.targetLocale || this.targetLocale;
+		if (!targetLocale) {
+			const error = noTargetLocaleProvidedError("translate");
+			gtInstanceLogger.error(error);
+			throw new Error(error);
+		}
+		targetLocale = this.resolveCanonicalLocale(targetLocale);
+		const sourceLocale = this.resolveCanonicalLocale(options?.sourceLocale || this.sourceLocale || "en");
+		return (await _translateMany([source], {
+			...options,
+			targetLocale,
+			sourceLocale
+		}, this._getTranslationConfig(), timeout))[0];
+	}
+	async translateMany(sources, options, timeout) {
+		if (typeof options === "string") options = { targetLocale: options };
+		this._validateAuth("translateMany");
+		let targetLocale = options?.targetLocale || this.targetLocale;
+		if (!targetLocale) {
+			const error = noTargetLocaleProvidedError("translateMany");
+			gtInstanceLogger.error(error);
+			throw new Error(error);
+		}
+		targetLocale = this.resolveCanonicalLocale(targetLocale);
+		const sourceLocale = this.resolveCanonicalLocale(options?.sourceLocale || this.sourceLocale || "en");
+		return await _translateMany(sources, {
+			...options,
+			targetLocale,
+			sourceLocale
+		}, this._getTranslationConfig(), timeout);
+	}
+	/**
+	* Uploads source files to the translation service without any translation content.
+	*
+	* This method creates or replaces source file entries in your project. Each uploaded
+	* file becomes a source that can later be translated into target languages. The files
+	* are processed and stored as base entries that serve as the foundation for generating
+	* translations through the translation workflow.
+	*
+	* @param {Array<{source: FileUpload}>} files - Array of objects containing source file data to upload
+	* @param {UploadFilesOptions} options - Configuration options including source locale and other upload settings
+	* @returns {Promise<UploadFilesResponse>} Upload result containing file IDs, version information, and upload status
+	*/
+	async uploadSourceFiles(files, options) {
+		this._validateAuth("uploadSourceFiles");
+		const mergedOptions = {
+			...options,
+			sourceLocale: this.resolveCanonicalLocale(options.sourceLocale ?? this.sourceLocale ?? "en")
+		};
+		files = files.map((f) => ({
+			...f,
+			source: {
+				...f.source,
+				locale: this.resolveCanonicalLocale(f.source.locale)
+			}
+		}));
+		const result = await _uploadSourceFiles(files, mergedOptions, this._getTranslationConfig());
+		return {
+			uploadedFiles: result.data,
+			count: result.count,
+			message: `Successfully uploaded ${result.count} files in ${result.batchCount} batch(es)`
+		};
+	}
+	/**
+	* Uploads translation files that correspond to previously uploaded source files.
+	*
+	* This method allows you to provide translated content for existing source files in your project.
+	* Each translation must reference an existing source file and include the translated content
+	* along with the target locale information. This is used when you have pre-existing translations
+	* that you want to upload directly rather than generating them through the translation service.
+	*
+	* @param {Array<{source: FileUpload, translations: FileUpload[]}>} files - Array of file objects where:
+	*   - `source`: Reference to the existing source file (contains IDs but no content)
+	*   - `translations`: Array of translated files, each containing content, locale, and reference IDs
+	* @param {UploadFilesOptions} options - Configuration options including source locale and upload settings
+	* @returns {Promise<UploadFilesResponse>} Upload result containing translation IDs, status, and processing information
+	*/
+	async uploadTranslations(files, options) {
+		this._validateAuth("uploadTranslations");
+		const mergedOptions = {
+			...options,
+			sourceLocale: options.sourceLocale ?? this.sourceLocale
+		};
+		if (!mergedOptions.sourceLocale) {
+			const error = noSourceLocaleProvidedError("uploadTranslations");
+			gtInstanceLogger.error(error);
+			throw new Error(error);
+		}
+		const result = await _uploadTranslations(files.map((f) => ({
+			...f,
+			translations: f.translations.map((t) => ({
+				...t,
+				locale: this.resolveCanonicalLocale(t.locale)
+			}))
+		})), mergedOptions, this._getTranslationConfig());
+		return {
+			uploadedFiles: result.data,
+			count: result.count,
+			message: `Successfully uploaded ${result.count} files in ${result.batchCount} batch(es)`
+		};
+	}
+	/**
+	* Formats a string with cutoff behavior, applying a terminator when the string exceeds the maximum character limit.
+	*
+	* This method uses the GT instance's rendering locales by default for locale-specific terminator selection,
+	* but can be overridden with custom locales in the options.
+	*
+	* @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. Defaults to instance's rendering locales.
+	* @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
+	* const gt = new GT({ targetLocale: 'en-US' });
+	* gt.formatCutoff('Hello, world!', { maxChars: 8 });
+	* // Returns: 'Hello, w...'
+	*
+	* @example
+	* gt.formatCutoff('Hello, world!', { maxChars: -3 });
+	* // Returns: '...ld!'
+	*/
+	formatCutoff(value, options) {
+		return this.localeConfig.formatCutoff(value, this.targetLocale, options);
+	}
+	/**
+	* 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 {FormatVariables} [variables={}] - The variables to use for formatting.
+	* @param {StringFormat} [dataFormat='ICU'] - The format of the message.
+	* @returns {string} The formatted message.
+	*
+	* @example
+	* gt.formatMessage('Hello {name}', { name: 'John' });
+	* // Returns: "Hello John"
+	*
+	* gt.formatMessage('Hello {name}', { name: 'John' }, { locales: ['fr'] });
+	* // Returns: "Bonjour John"
+	*/
+	formatMessage(message, options) {
+		return this.localeConfig.formatMessage(message, this.targetLocale, options);
+	}
+	/**
+	* Formats a number according to the specified locales and options.
+	*
+	* @param {number} number - The number to format
+	* @param {Object} [options] - Additional options for number formatting
+	* @param {string | string[]} [options.locales] - The locales to use for formatting
+	* @param {Intl.NumberFormatOptions} [options] - Additional Intl.NumberFormat options
+	* @returns {string} The formatted number
+	*
+	* @example
+	* gt.formatNum(1234.56, { style: 'currency', currency: 'USD' });
+	* // Returns: "$1,234.56"
+	*/
+	formatNum(number, options) {
+		return this.localeConfig.formatNum(number, this.targetLocale, options);
+	}
+	/**
+	* Formats a date according to the specified locales and options.
+	*
+	* @param {Date} date - The date to format
+	* @param {Object} [options] - Additional options for date formatting
+	* @param {string | string[]} [options.locales] - The locales to use for formatting
+	* @param {Intl.DateTimeFormatOptions} [options] - Additional Intl.DateTimeFormat options
+	* @returns {string} The formatted date
+	*
+	* @example
+	* gt.formatDateTime(new Date(), { dateStyle: 'full', timeStyle: 'long' });
+	* // Returns: "Thursday, March 14, 2024 at 2:30:45 PM GMT-7"
+	*/
+	formatDateTime(date, options) {
+		return this.localeConfig.formatDateTime(date, this.targetLocale, options);
+	}
+	/**
+	* Formats a currency value according to the specified locales and options.
+	*
+	* @param {number} value - The currency value to format
+	* @param {string} currency - The currency code (e.g., 'USD', 'EUR')
+	* @param {Object} [options] - Additional options for currency formatting
+	* @param {string | string[]} [options.locales] - The locales to use for formatting
+	* @param {Intl.NumberFormatOptions} [options] - Additional Intl.NumberFormat options
+	* @returns {string} The formatted currency value
+	*
+	* @example
+	* gt.formatCurrency(1234.56, 'USD', { style: 'currency' });
+	* // Returns: "$1,234.56"
+	*/
+	formatCurrency(value, currency, options) {
+		return this.localeConfig.formatCurrency(value, currency, this.targetLocale, options);
+	}
+	/**
+	* Formats a list of items according to the specified locales and options.
+	*
+	* @param {Array<string | number>} array - The list of items to format
+	* @param {Object} [options] - Additional options for list formatting
+	* @param {string | string[]} [options.locales] - The locales to use for formatting
+	* @param {Intl.ListFormatOptions} [options] - Additional Intl.ListFormat options
+	* @returns {string} The formatted list
+	*
+	* @example
+	* gt.formatList(['apple', 'banana', 'orange'], { type: 'conjunction' });
+	* // Returns: "apple, banana, and orange"
+	*/
+	formatList(array, options) {
+		return this.localeConfig.formatList(array, this.targetLocale, options);
+	}
+	/**
+	* Formats a list of items according to the specified locales and options.
+	* @param {Array<T>} array - The list of items to format
+	* @param {Object} [options] - Additional options for list formatting
+	* @param {string | string[]} [options.locales] - The locales to use for formatting
+	* @param {Intl.ListFormatOptions} [options] - Additional Intl.ListFormat options
+	* @returns {Array<T | string>} The formatted list parts
+	*
+	* @example
+	* gt.formatListToParts(['apple', 42, { foo: 'bar' }], { type: 'conjunction', style: 'short', locales: ['en'] });
+	* // Returns: ['apple', ', ', 42, ' and ', '{ foo: "bar" }']
+	*/
+	formatListToParts(array, options) {
+		return this.localeConfig.formatListToParts(array, this.targetLocale, options);
+	}
+	/**
+	* Formats a relative time value according to the specified locales and options.
+	*
+	* @param {number} value - The relative time value to format
+	* @param {Intl.RelativeTimeFormatUnit} unit - The unit of time (e.g., 'second', 'minute', 'hour', 'day', 'week', 'month', 'year')
+	* @param {Object} options - Additional options for relative time formatting
+	* @param {string | string[]} [options.locales] - The locales to use for formatting
+	* @param {Intl.RelativeTimeFormatOptions} [options] - Additional Intl.RelativeTimeFormat options
+	* @returns {string} The formatted relative time string
+	*
+	* @example
+	* gt.formatRelativeTime(-1, 'day', { locales: ['en-US'], numeric: 'auto' });
+	* // Returns: "yesterday"
+	*/
+	formatRelativeTime(value, unit, options) {
+		return this.localeConfig.formatRelativeTime(value, unit, this.targetLocale, options);
+	}
+	/**
+	* Formats a relative time string from a Date, automatically selecting the best unit.
+	*
+	* @param {Date} date - The date to format relative to now
+	* @param {Object} [options] - Additional options for relative time formatting
+	* @param {string | string[]} [options.locales] - The locales to use for formatting
+	* @returns {string} The formatted relative time string (e.g., "2 hours ago", "in 3 days")
+	*
+	* @example
+	* gt.formatRelativeTimeFromDate(new Date(Date.now() - 3600000));
+	* // Returns: "1 hour ago"
+	*/
+	formatRelativeTimeFromDate(date, options) {
+		return this.localeConfig.formatRelativeTimeFromDate(date, this.targetLocale, options);
+	}
+	/**
+	* Retrieves the display name of a locale code using Intl.DisplayNames, returning an empty string if no name is found.
+	*
+	* @param {string} [locale=this.targetLocale] - A BCP-47 locale code
+	* @returns {string} The display name corresponding to the code
+	* @throws {Error} If no target locale is provided
+	*
+	* @example
+	* gt.getLocaleName('es-ES');
+	* // Returns: "Spanish (Spain)"
+	*/
+	getLocaleName(locale = this.targetLocale) {
+		if (!locale) throw new Error(noTargetLocaleProvidedError("getLocaleName"));
+		return this.localeConfig.getLocaleName(locale);
+	}
+	/**
+	* Retrieves an emoji based on a given locale code.
+	* Uses the locale's region (if present) to select an emoji or falls back on default emojis.
+	*
+	* @param {string} [locale=this.targetLocale] - A BCP-47 locale code (e.g., 'en-US', 'fr-CA')
+	* @returns {string} The emoji representing the locale or its region
+	* @throws {Error} If no target locale is provided
+	*
+	* @example
+	* gt.getLocaleEmoji('es-ES');
+	* // Returns: "🇪🇸"
+	*/
+	getLocaleEmoji(locale = this.targetLocale) {
+		if (!locale) throw new Error(noTargetLocaleProvidedError("getLocaleEmoji"));
+		return this.localeConfig.getLocaleEmoji(locale);
+	}
+	/**
+	* Generates linguistic details for a given locale code.
+	*
+	* This function returns information about the locale,
+	* script, and region of a given language code both in a standard form and in a maximized form (with likely script and region).
+	* The function provides these names in both your default language and native forms, and an associated emoji.
+	*
+	* @param {string} [locale=this.targetLocale] - The locale code to get properties for (e.g., "de-AT").
+	* @returns {LocaleProperties} - An object containing detailed information about the locale.
+	*
+	* @property {string} code - The full locale code, e.g., "de-AT".
+	* @property {string} name - Language name in the default display language, e.g., "Austrian German".
+	* @property {string} nativeName - Language name in the locale's native language, e.g., "Österreichisches Deutsch".
+	* @property {string} languageCode - The base language code, e.g., "de".
+	* @property {string} languageName - The language name in the default display language, e.g., "German".
+	* @property {string} nativeLanguageName - The language name in the native language, e.g., "Deutsch".
+	* @property {string} nameWithRegionCode - Language name with region in the default language, e.g., "German (AT)".
+	* @property {string} nativeNameWithRegionCode - Language name with region in the native language, e.g., "Deutsch (AT)".
+	* @property {string} regionCode - The region code from maximization, e.g., "AT".
+	* @property {string} regionName - The region name in the default display language, e.g., "Austria".
+	* @property {string} nativeRegionName - The region name in the native language, e.g., "Österreich".
+	* @property {string} scriptCode - The script code from maximization, e.g., "Latn".
+	* @property {string} scriptName - The script name in the default display language, e.g., "Latin".
+	* @property {string} nativeScriptName - The script name in the native language, e.g., "Lateinisch".
+	* @property {string} maximizedCode - The maximized locale code, e.g., "de-Latn-AT".
+	* @property {string} maximizedName - Maximized locale name with likely script in the default language, e.g., "Austrian German (Latin)".
+	* @property {string} nativeMaximizedName - Maximized locale name in the native language, e.g., "Österreichisches Deutsch (Lateinisch)".
+	* @property {string} minimizedCode - Minimized locale code, e.g., "de-AT" (or "de" for "de-DE").
+	* @property {string} minimizedName - Minimized language name in the default language, e.g., "Austrian German".
+	* @property {string} nativeMinimizedName - Minimized language name in the native language, e.g., "Österreichisches Deutsch".
+	* @property {string} emoji - The emoji associated with the locale's region, if applicable.
+	*/
+	getLocaleProperties(locale = this.targetLocale) {
+		if (!locale) throw new Error(noTargetLocaleProvidedError("getLocaleProperties"));
+		return this.localeConfig.getLocaleProperties(locale);
+	}
+	/**
+	* Retrieves multiple properties for a given region code, including:
+	* - `code`: the original region code
+	* - `name`: the localized display name
+	* - `emoji`: the associated flag or symbol
+	*
+	* Behavior:
+	* - Accepts ISO 3166-1 alpha-2 or UN M.49 region codes (e.g., `"US"`, `"FR"`, `"419"`).
+	* - Uses the instance's `targetLocale` to localize the region name for the user.
+	* - If `customMapping` contains a `name` or `emoji` for the region, those override the default values.
+	* - Otherwise, uses `Intl.DisplayNames` to get the localized region name, falling back to `libraryDefaultLocale`.
+	* - Falls back to the region code as `name` if display name resolution fails.
+	* - Falls back to a default emoji if no emoji mapping is found in built-in data or `customMapping`.
+	*
+	* @param {string} [region=this.getLocaleProperties().regionCode] - The region code to look up (e.g., `"US"`, `"GB"`, `"DE"`).
+	* @param {CustomRegionMapping} [customMapping] - Optional mapping of region codes to custom names and/or emojis.
+	* @returns {{ code: string, name: string, emoji: string }} An object containing:
+	*  - `code`: the input region code
+	*  - `name`: the localized or custom region name
+	*  - `emoji`: the matching emoji flag or symbol
+	*
+	* @throws {Error} If no target locale is available to determine region properties.
+	*
+	* @example
+	* const gt = new GT({ targetLocale: 'en-US' });
+	* gt.getRegionProperties('US');
+	* // => { code: 'US', name: 'United States', emoji: '🇺🇸' }
+	*
+	* @example
+	* const gt = new GT({ targetLocale: 'fr-FR' });
+	* gt.getRegionProperties('US');
+	* // => { code: 'US', name: 'États-Unis', emoji: '🇺🇸' }
+	*
+	* @example
+	* gt.getRegionProperties('US', { US: { name: 'USA', emoji: '🗽' } });
+	* // => { code: 'US', name: 'USA', emoji: '🗽' }
+	*/
+	getRegionProperties(region = this.getLocaleProperties().regionCode, customMapping) {
+		if (!customMapping) {
+			if (this.customMapping && !this.customRegionMapping) {
+				const customRegionMapping = {};
+				for (const [locale, lp] of Object.entries(this.customMapping)) if (lp && typeof lp === "object" && lp.regionCode && !customRegionMapping[lp.regionCode]) {
+					const { regionName: name, emoji } = lp;
+					customRegionMapping[lp.regionCode] = {
+						locale,
+						...name && { name },
+						...emoji && { emoji }
+					};
+				}
+				this.customRegionMapping = customRegionMapping;
+			}
+			customMapping = this.customRegionMapping;
+		}
+		return _getRegionProperties(region, this.targetLocale, customMapping);
+	}
+	/**
+	* Determines whether a translation is required based on the source and target locales.
+	*
+	* @param {string} [sourceLocale=this.sourceLocale] - The locale code for the original content
+	* @param {string} [targetLocale=this.targetLocale] - The locale code to translate into
+	* @param {string[]} [approvedLocales=this.locales] - Optional array of approved target locales
+	* @returns {boolean} True if translation is required, false otherwise
+	* @throws {Error} If no source locale is provided
+	* @throws {Error} If no target locale is provided
+	*
+	* @example
+	* gt.requiresTranslation('en-US', 'es-ES');
+	* // Returns: true
+	*/
+	requiresTranslation(sourceLocale = this.sourceLocale, targetLocale = this.targetLocale, approvedLocales = this.locales, customMapping = this.customMapping) {
+		if (!sourceLocale) throw new Error(noSourceLocaleProvidedError("requiresTranslation"));
+		if (!targetLocale) throw new Error(noTargetLocaleProvidedError("requiresTranslation"));
+		if (customMapping === this.customMapping) return this.localeConfig.requiresTranslation(targetLocale, sourceLocale, approvedLocales);
+		return _requiresTranslation(sourceLocale, targetLocale, approvedLocales, customMapping);
+	}
+	/**
+	* Determines the best matching locale from the provided approved locales list.
+	*
+	* @param {string | string[]} locales - A single locale or array of locales in preference order
+	* @param {string[]} [approvedLocales=this.locales] - Array of approved locales in preference order
+	* @returns {string | undefined} The best matching locale or undefined if no match is found
+	*
+	* @example
+	* gt.determineLocale(['fr-CA', 'fr-FR'], ['en-US', 'fr-FR', 'es-ES']);
+	* // Returns: "fr-FR"
+	*/
+	determineLocale(locales, approvedLocales = this.locales || [], customMapping = this.customMapping) {
+		if (customMapping === this.customMapping) return this.localeConfig.determineLocale(locales, approvedLocales ?? []);
+		return _determineLocale(locales, approvedLocales, customMapping);
+	}
+	/**
+	* Gets the text direction for a given locale code.
+	*
+	* @param {string} [locale=this.targetLocale] - A BCP-47 locale code
+	* @returns {'ltr' | 'rtl'} 'rtl' if the locale is right-to-left, otherwise 'ltr'
+	* @throws {Error} If no target locale is provided
+	*
+	* @example
+	* gt.getLocaleDirection('ar-SA');
+	* // Returns: "rtl"
+	*/
+	getLocaleDirection(locale = this.targetLocale) {
+		if (!locale) throw new Error(noTargetLocaleProvidedError("getLocaleDirection"));
+		return this.localeConfig.getLocaleDirection(locale);
+	}
+	/**
+	* Checks if a given BCP 47 locale code is valid.
+	*
+	* @param {string} [locale=this.targetLocale] - The BCP 47 locale code to validate
+	* @param {customMapping} [customMapping=this.customMapping] - The custom mapping to use for validation
+	* @returns {boolean} True if the locale code is valid, false otherwise
+	* @throws {Error} If no target locale is provided
+	*
+	* @example
+	* gt.isValidLocale('en-US');
+	* // Returns: true
+	*/
+	isValidLocale(locale = this.targetLocale, customMapping = this.customMapping) {
+		if (!locale) throw new Error(noTargetLocaleProvidedError("isValidLocale"));
+		if (customMapping === this.customMapping) return this.localeConfig.isValidLocale(locale);
+		return _isValidLocale(locale, customMapping);
+	}
+	/**
+	* 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
+	*/
+	resolveCanonicalLocale(locale = this.targetLocale, customMapping = this.customMapping) {
+		if (!locale) throw new Error(noTargetLocaleProvidedError("resolveCanonicalLocale"));
+		if (customMapping === this.customMapping) return this.localeConfig.resolveCanonicalLocale(locale);
+		return _resolveCanonicalLocale(locale, customMapping);
+	}
+	/**
+	* 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
+	*/
+	resolveAliasLocale(locale, customMapping = this.customMapping) {
+		if (!locale) throw new Error(noTargetLocaleProvidedError("resolveAliasLocale"));
+		if (customMapping === this.customMapping) return this.localeConfig.resolveAliasLocale(locale);
+		return _resolveAliasLocale(locale, customMapping);
+	}
+	/**
+	* Standardizes a BCP 47 locale code to ensure correct formatting.
+	*
+	* @param {string} [locale=this.targetLocale] - The BCP 47 locale code to standardize
+	* @returns {string} The standardized locale code or empty string if invalid
+	* @throws {Error} If no target locale is provided
+	*
+	* @example
+	* gt.standardizeLocale('en_us');
+	* // Returns: "en-US"
+	*/
+	standardizeLocale(locale = this.targetLocale) {
+		if (!locale) throw new Error(noTargetLocaleProvidedError("standardizeLocale"));
+		return this.localeConfig.standardizeLocale(locale);
+	}
+	/**
+	* Checks if multiple BCP 47 locale codes represent the same dialect.
+	*
+	* @param {...(string | string[])} locales - The BCP 47 locale codes to compare
+	* @returns {boolean} True if all codes represent the same dialect, false otherwise
+	*
+	* @example
+	* gt.isSameDialect('en-US', 'en-GB');
+	* // Returns: false
+	*
+	* gt.isSameDialect('en', 'en-US');
+	* // Returns: true
+	*/
+	isSameDialect(...locales) {
+		return this.localeConfig.isSameDialect(...locales);
+	}
+	/**
+	* Checks if multiple BCP 47 locale codes represent the same language.
+	*
+	* @param {...(string | string[])} locales - The BCP 47 locale codes to compare
+	* @returns {boolean} True if all codes represent the same language, false otherwise
+	*
+	* @example
+	* gt.isSameLanguage('en-US', 'en-GB');
+	* // Returns: true
+	*/
+	isSameLanguage(...locales) {
+		return this.localeConfig.isSameLanguage(...locales);
+	}
+	/**
+	* Checks if a locale is a superset of another locale.
+	*
+	* @param {string} superLocale - The locale to check if it is a superset
+	* @param {string} subLocale - The locale to check if it is a subset
+	* @returns {boolean} True if superLocale is a superset of subLocale, false otherwise
+	*
+	* @example
+	* gt.isSupersetLocale('en', 'en-US');
+	* // Returns: true
+	*
+	* gt.isSupersetLocale('en-US', 'en');
+	* // Returns: false
+	*/
+	isSupersetLocale(superLocale, subLocale) {
+		return this.localeConfig.isSupersetLocale(superLocale, subLocale);
+	}
+};
+/**
+* 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, w...'
+*
+* @example
+* formatCutoff('Hello, world!', { locales: 'en-US', maxChars: -3 });
+* // Returns: '...ld!'
+*
+* @example
+* formatCutoff('Very long text that needs cutting', {
+*   locales: 'en-US',
+*   maxChars: 15,
+*   style: 'ellipsis',
+*   separator: ' '
+* });
+* // Returns: 'Very long text ...'
+*/
+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 {string | string[]} [locales='en'] - The locales to use for formatting.
+* @param {FormatVariables} [variables={}] - The variables to use for formatting.
+* @param {StringFormat} [dataFormat='ICU'] - The format of the message. (When STRING, the message is returned as is)
+* @returns {string} The formatted message.
+*
+* @example
+* formatMessage('Hello {name}', { name: 'John' });
+* // Returns: "Hello John"
+*
+* formatMessage('Hello {name}', { name: 'John' }, { locales: ['fr'] });
+* // Returns: "Bonjour John"
+*/
+function formatMessage(message, options) {
+	switch (options?.dataFormat) {
+		case "STRING": return _formatMessageString(message);
+		default: return _formatMessageICU(message, options?.locales, options?.variables);
+	}
+}
+/**
+* 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 {Intl.NumberFormatOptions} [params.options] - Additional options for number formatting.
+* @param {string | string[]} [params.options.locales] - The locales to use for formatting.
+* @returns {string} The formatted number.
+*/
+function formatNum(number, options) {
+	return _formatNum({
+		value: number,
+		locales: options.locales,
+		options
+	});
+}
+/**
+* Formats a date according to the specified languages and options.
+* @param {Object} params - The parameters for the date formatting.
+* @param {Date} params.value - The date to format.
+* @param {Intl.DateTimeFormatOptions} [params.options] - Additional options for date formatting.
+* @param {string | string[]} [params.options.locales] - The languages to use for formatting.
+* @returns {string} The formatted date.
+*/
+function formatDateTime(date, options) {
+	return _formatDateTime({
+		value: date,
+		locales: options?.locales,
+		options
+	});
+}
+/**
+* Formats a currency value according to the specified languages, 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 {Intl.NumberFormatOptions} [params.options={}] - Additional options for currency formatting.
+* @param {string | string[]} [params.options.locales] - The locale codes to use for formatting.
+* @returns {string} The formatted currency value.
+*/
+function formatCurrency(value, currency, options) {
+	return _formatCurrency({
+		value,
+		currency,
+		locales: options.locales,
+		options
+	});
+}
+/**
+* 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 {Intl.ListFormatOptions} [params.options={}] - Additional options for list formatting.
+* @param {string | string[]} [params.options.locales] - The locales to use for formatting.
+* @returns {string} The formatted list.
+*/
+function formatList(array, options) {
+	return _formatList({
+		value: array,
+		locales: options.locales,
+		options
+	});
+}
+/**
+* Formats a list of items according to the specified locales and options.
+* @param {Array<T>} array - The list of items to format
+* @param {Object} [options] - Additional options for list formatting
+* @param {string | string[]} [options.locales] - The locales to use for formatting
+* @param {Intl.ListFormatOptions} [options] - Additional Intl.ListFormat options
+* @returns {Array<T | string>} The formatted list parts
+*/
+function formatListToParts(array, options) {
+	return _formatListToParts({
+		value: array,
+		locales: options?.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 {Intl.RelativeTimeFormatOptions} [params.options={}] - Additional options for relative time formatting.
+* @param {string | string[]} [params.options.locales] - The locales to use for formatting.
+* @returns {string} The formatted relative time string.
+*/
+function formatRelativeTime(value, unit, options) {
+	return _formatRelativeTime({
+		value,
+		unit,
+		locales: options.locales,
+		options
+	});
+}
+/**
+* Formats a relative time string from a Date, automatically selecting the best unit.
+* @param {Date} date - The date to format relative to now.
+* @param {Object} options - Formatting options.
+* @param {string | string[]} options.locales - The locales to use for formatting.
+* @param {Intl.RelativeTimeFormatOptions} [options] - Additional Intl.RelativeTimeFormat options.
+* @returns {string} The formatted relative time string (e.g., "2 hours ago", "in 3 days").
+*/
+function formatRelativeTimeFromDate(date, options) {
+	const { locales, baseDate, ...intlOptions } = options;
+	return _formatRelativeTimeFromDate({
+		date,
+		baseDate: baseDate ?? /* @__PURE__ */ new Date(),
+		locales,
+		options: intlOptions
+	});
+}
+/**
+* Retrieves the display name of locale code using Intl.DisplayNames.
+*
+* @param {string} locale - A BCP-47 locale code.
+* @param {string} [defaultLocale] - The default locale to use for formatting.
+* @param {CustomMapping} [customMapping] - A custom mapping of locale codes to their names.
+* @returns {string} The display name corresponding to the code.
+*/
+function getLocaleName(locale, defaultLocale, customMapping) {
+	return _getLocaleName(locale, defaultLocale, customMapping);
+}
+/**
+* Retrieves an emoji based on a given locale code, taking into account region, language, and specific exceptions.
+*
+* This function uses the locale's region (if present) to select an emoji or falls back on default emojis for certain languages.
+*
+* @param locale - A string representing the locale code (e.g., 'en-US', 'fr-CA').
+* @param {CustomMapping} [customMapping] - A custom mapping of locale codes to their names.
+* @returns The emoji representing the locale or its region, or a default emoji if no specific match is found.
+*/
+function getLocaleEmoji(locale, customMapping) {
+	return _getLocaleEmoji(locale, customMapping);
+}
+/**
+* Generates linguistic details for a given locale code.
+*
+* This function returns information about the locale,
+* script, and region of a given language code both in a standard form and in a maximized form (with likely script and region).
+* The function provides these names in both your default language and native forms, and an associated emoji.
+*
+* @param {string} locale - The locale code to get properties for (e.g., "de-AT").
+* @param {string} [defaultLocale] - The default locale to use for formatting.
+* @param {CustomMapping} [customMapping] - A custom mapping of locale codes to their names.
+* @returns {LocaleProperties} - An object containing detailed information about the locale.
+*
+* @property {string} code - The full locale code, e.g., "de-AT".
+* @property {string} name - Language name in the default display language, e.g., "Austrian German".
+* @property {string} nativeName - Language name in the locale's native language, e.g., "Österreichisches Deutsch".
+* @property {string} languageCode - The base language code, e.g., "de".
+* @property {string} languageName - The language name in the default display language, e.g., "German".
+* @property {string} nativeLanguageName - The language name in the native language, e.g., "Deutsch".
+* @property {string} nameWithRegionCode - Language name with region in the default language, e.g., "German (AT)".
+* @property {string} nativeNameWithRegionCode - Language name with region in the native language, e.g., "Deutsch (AT)".
+* @property {string} regionCode - The region code from maximization, e.g., "AT".
+* @property {string} regionName - The region name in the default display language, e.g., "Austria".
+* @property {string} nativeRegionName - The region name in the native language, e.g., "Österreich".
+* @property {string} scriptCode - The script code from maximization, e.g., "Latn".
+* @property {string} scriptName - The script name in the default display language, e.g., "Latin".
+* @property {string} nativeScriptName - The script name in the native language, e.g., "Lateinisch".
+* @property {string} maximizedCode - The maximized locale code, e.g., "de-Latn-AT".
+* @property {string} maximizedName - Maximized locale name with likely script in the default language, e.g., "Austrian German (Latin)".
+* @property {string} nativeMaximizedName - Maximized locale name in the native language, e.g., "Österreichisches Deutsch (Lateinisch)".
+* @property {string} minimizedCode - Minimized locale code, e.g., "de-AT" (or "de" for "de-DE").
+* @property {string} minimizedName - Minimized language name in the default language, e.g., "Austrian German".
+* @property {string} nativeMinimizedName - Minimized language name in the native language, e.g., "Österreichisches Deutsch".
+* @property {string} emoji - The emoji associated with the locale's region, if applicable.
+*/
+function getLocaleProperties(locale, defaultLocale, customMapping) {
+	return _getLocaleProperties(locale, defaultLocale, customMapping);
+}
+/**
+* Retrieves multiple properties for a given region code, including:
+* - `code`: the original region code
+* - `name`: the localized display name
+* - `emoji`: the associated flag or symbol
+*
+* Behavior:
+* - Accepts ISO 3166-1 alpha-2 or UN M.49 region codes (e.g., `"US"`, `"FR"`, `"419"`).
+* - If `customMapping` contains a `name` or `emoji` for the region, those override the default values.
+* - Otherwise, uses `Intl.DisplayNames` to get the localized region name in the given `defaultLocale`,
+*   falling back to `libraryDefaultLocale`.
+* - Falls back to the region code as `name` if display name resolution fails.
+* - Falls back to `defaultEmoji` if no emoji mapping is found in `emojis` or `customMapping`.
+*
+* @param {string} region - The region code to look up (e.g., `"US"`, `"GB"`, `"DE"`).
+* @param {string} [defaultLocale=libraryDefaultLocale] - The locale to use when localizing the region name.
+* @param {CustomRegionMapping} [customMapping] - Optional mapping of region codes to custom names and/or emojis.
+* @returns {{ code: string, name: string, emoji: string }} An object containing:
+*  - `code`: the input region code
+*  - `name`: the localized or custom region name
+*  - `emoji`: the matching emoji flag or symbol
+*
+* @example
+* getRegionProperties('US', 'en');
+* // => { code: 'US', name: 'United States', emoji: '🇺🇸' }
+*
+* @example
+* getRegionProperties('US', 'fr');
+* // => { code: 'US', name: 'États-Unis', emoji: '🇺🇸' }
+*
+* @example
+* getRegionProperties('US', 'en', { US: { name: 'USA', emoji: '🗽' } });
+* // => { code: 'US', name: 'USA', emoji: '🗽' }
+*/
+function getRegionProperties(region, defaultLocale, customMapping) {
+	return _getRegionProperties(region, defaultLocale, customMapping);
+}
+/**
+* Determines whether a translation is required based on the source and target locales.
+*
+* - If the target locale is not specified, the function returns `false`, as translation is not needed.
+* - If the source and target locale are the same, returns `false`, indicating that no translation is necessary.
+* - If the `approvedLocales` array is provided, and the target locale is not within that array, the function also returns `false`.
+* - Otherwise, it returns `true`, meaning that a translation is required.
+*
+* @param {string} sourceLocale - The locale code for the original content (BCP 47 locale code).
+* @param {string} targetLocale - The locale code of the language to translate the content into (BCP 47 locale code).
+* @param {string[]} [approvedLocale] - An optional array of approved target locales.
+*
+* @returns {boolean} - Returns `true` if translation is required, otherwise `false`.
+*/
+function requiresTranslation(sourceLocale, targetLocale, approvedLocales, customMapping) {
+	return _requiresTranslation(sourceLocale, targetLocale, approvedLocales, customMapping);
+}
+/**
+* Determines the best matching locale from the provided approved locales list.
+* @param {string | string[]} locales - A single locale or an array of locales sorted in preference order.
+* @param {string[]} [approvedLocales=this.locales] - An array of approved locales, also sorted by preference.
+* @returns {string | undefined} - The best matching locale from the approvedLocales list, or undefined if no match is found.
+*/
+function determineLocale(locales, approvedLocales = [], customMapping = void 0) {
+	return _determineLocale(locales, approvedLocales, customMapping);
+}
+/**
+* Get the text direction for a given locale code using the Intl.Locale API.
+*
+* @param {string} locale - A BCP-47 locale code.
+* @returns {string} - 'rtl' if the locale is right-to-left, otherwise 'ltr'.
+*/
+function getLocaleDirection(locale) {
+	return _getLocaleDirection(locale);
+}
+/**
+* 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.
+*/
+function isValidLocale(locale, customMapping) {
+	return _isValidLocale(locale, customMapping);
+}
+/**
+* Resolves the alias locale for a given locale.
+* @param {string} locale - The locale to resolve the alias locale for
+* @param {CustomMapping} [customMapping] - The custom mapping to use for resolving the alias locale
+* @returns {string} The alias locale
+*/
+function resolveAliasLocale(locale, customMapping) {
+	return _resolveAliasLocale(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
+*/
+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.
+*/
+function standardizeLocale(locale) {
+	return _standardizeLocale(locale);
+}
+/**
+* Checks if multiple BCP 47 locale codes represent the same dialect.
+* @param {string[]} locales - The BCP 47 locale codes to compare.
+* @returns {boolean} True if all BCP 47 codes represent the same dialect, false otherwise.
+*/
+function isSameDialect(...locales) {
+	return _isSameDialect(...locales);
+}
+/**
+* Checks if multiple BCP 47 locale codes represent the same language.
+* @param {string[]} locales - The BCP 47 locale codes to compare.
+* @returns {boolean} True if all BCP 47 codes represent the same language, false otherwise.
+*/
+function isSameLanguage(...locales) {
+	return _isSameLanguage(...locales);
+}
+/**
+* Checks if a locale is a superset of another locale.
+* A subLocale is a subset of superLocale if it is an extension of superLocale or are otherwise identical.
+*
+* @param {string} superLocale - The locale to check if it is a superset of the other locale.
+* @param {string} subLocale - The locale to check if it is a subset of the other locale.
+* @returns {boolean} True if the first locale is a superset of the second locale, false otherwise.
+*/
+function isSupersetLocale(superLocale, subLocale) {
+	return _isSupersetLocale(superLocale, subLocale);
+}
+const API_VERSION = API_VERSION$1;
+//#endregion
+export { API_VERSION, GT, LocaleConfig, determineLocale, formatCurrency, formatCutoff, formatDateTime, formatList, formatListToParts, formatMessage, formatNum, formatRelativeTime, formatRelativeTimeFromDate, getLocaleDirection, getLocaleEmoji, getLocaleName, getLocaleProperties, getRegionProperties, isSameDialect, isSameLanguage, isSupersetLocale, isValidLocale, requiresTranslation, resolveAliasLocale, resolveCanonicalLocale, standardizeLocale };
+
+//# sourceMappingURL=index.mjs.map