generaltranslation 8.2.13 → 8.2.14

package/dist/core-7RP541eY.cjs

@@ -1,1677 +0,0 @@
-const require_IntlCache = require("./IntlCache-CAW8tKhd.cjs");
-let intl_messageformat = require("intl-messageformat");
-//#region src/locales/isValidLocale.ts
-const scriptExceptions = [
-	"Cham",
-	"Jamo",
-	"Kawi",
-	"Lisu",
-	"Toto",
-	"Thai"
-];
-const isCustomLanguage = (language) => {
-	return language >= "qaa" && language <= "qtz";
-};
-/**
-* Checks if a given BCP 47 language code is valid.
-* @param {string} code - The BCP 47 language code to validate.
-* @param {CustomMapping} [customMapping] - The custom mapping to use for validation.
-* @returns {boolean} True if the BCP 47 code is valid, false otherwise.
-* @internal
-*/
-const _isValidLocale = (locale, customMapping) => {
-	if (customMapping?.[locale] && typeof customMapping[locale] === "object" && "code" in customMapping[locale] && customMapping[locale].code) locale = customMapping[locale].code;
-	try {
-		const { language, region, script } = require_IntlCache.intlCache.get("Locale", locale);
-		if (locale.split("-").length !== (() => {
-			let partCount = 1;
-			if (region) partCount += 1;
-			if (script) partCount += 1;
-			return partCount;
-		})()) return false;
-		if (require_IntlCache.intlCache.get("DisplayNames", ["en"], { type: "language" }).of(language) === language && !isCustomLanguage(language)) return false;
-		if (region) {
-			if (require_IntlCache.intlCache.get("DisplayNames", ["en"], { type: "region" }).of(region) === region) return false;
-		}
-		if (script) {
-			if (require_IntlCache.intlCache.get("DisplayNames", ["en"], { type: "script" }).of(script) === script && !scriptExceptions.includes(script)) return false;
-		}
-		return true;
-	} catch {
-		return false;
-	}
-};
-/**
-* Standardizes a BCP 47 locale to ensure correct formatting.
-* @param {string} locale - The BCP 47 locale to standardize.
-* @returns {string} The standardized BCP 47 locale, or the input string if it cannot be standardized.
-* @internal
-*/
-const _standardizeLocale = (locale) => {
-	try {
-		return Intl.getCanonicalLocales(locale)[0];
-	} catch {
-		return locale;
-	}
-};
-//#endregion
-//#region src/locales/isSameDialect.ts
-function checkTwoLocalesAreSameDialect(codeA, codeB) {
-	const { language: languageA, region: regionA, script: scriptA } = require_IntlCache.intlCache.get("Locale", codeA);
-	const { language: languageB, region: regionB, script: scriptB } = require_IntlCache.intlCache.get("Locale", codeB);
-	if (languageA !== languageB) return false;
-	if (regionA && regionB && regionA !== regionB) return false;
-	if (scriptA && scriptB && scriptA !== scriptB) return false;
-	return true;
-}
-/**
-* Test two or more language codes to determine if they are exactly the same
-* e.g. "en-US" and "en" would be exactly the same.
-* "en-GB" and "en" would be exactly the same.
-* "en-GB" and "en-US" would be different.
-* @internal
-*/
-function _isSameDialect(...locales) {
-	try {
-		const flattenedCodes = locales.flat().map(_standardizeLocale);
-		for (let i = 0; i < flattenedCodes.length; i++) for (let j = i + 1; j < flattenedCodes.length; j++) if (!checkTwoLocalesAreSameDialect(flattenedCodes[i], flattenedCodes[j])) return false;
-		return true;
-	} catch (error) {
-		console.error(error);
-		return false;
-	}
-}
-//#endregion
-//#region src/locales/isSameLanguage.ts
-/**
-* @internal
-*/
-function _isSameLanguage(...locales) {
-	try {
-		const languages = locales.flat().map((locale) => require_IntlCache.intlCache.get("Locale", locale).language);
-		return languages.every((language) => language === languages[0]);
-	} catch (error) {
-		console.error(error);
-		return false;
-	}
-}
-//#endregion
-//#region src/locales/requiresTranslation.ts
-/**
-* Given a target locale and a source locale, determines whether a translation is required
-* If the target locale and the source locale are the same, returns false, otherwise returns true
-* If a translation is not possible due to the target locale being outside of the optional approvedLanguages scope, also returns false
-* @internal
-*/
-function _requiresTranslation(sourceLocale, targetLocale, approvedLocales, customMapping) {
-	if (!_isValidLocale(sourceLocale, customMapping) || !_isValidLocale(targetLocale, customMapping) || approvedLocales && approvedLocales.some((approvedLocale) => !_isValidLocale(approvedLocale, customMapping))) return false;
-	if (_isSameDialect(sourceLocale, targetLocale)) return false;
-	if (approvedLocales && !approvedLocales.some((approvedLocale) => _isSameLanguage(targetLocale, approvedLocale))) return false;
-	return true;
-}
-//#endregion
-//#region src/locales/customLocaleMapping.ts
-const getCustomProperty = (customMapping, locale, property) => {
-	if (customMapping?.[locale]) {
-		if (typeof customMapping[locale] === "string") return property === "name" ? customMapping[locale] : void 0;
-		return customMapping[locale][property];
-	}
-};
-/**
-* Checks if a given locale should use the canonical locale.
-* @param locale - The locale to check if it should use the canonical locale
-* @param customMapping - The custom mapping to use for checking if the locale should use the canonical locale
-* @returns True if the locale should use the canonical locale, false otherwise
-*/
-const shouldUseCanonicalLocale = (locale, customMapping) => {
-	return !!(customMapping?.[locale] && typeof customMapping[locale] === "object" && "code" in customMapping[locale] && customMapping[locale].code && _isValidLocale(customMapping[locale].code));
-};
-//#endregion
-//#region src/locales/getLocaleEmoji.ts
-/**
-* @internal
-*/
-function _getLocaleEmoji(locale, customMapping) {
-	const aliasedLocale = locale;
-	if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) locale = customMapping[locale].code;
-	try {
-		const standardizedLocale = _standardizeLocale(locale);
-		const localeObject = require_IntlCache.intlCache.get("Locale", standardizedLocale);
-		const { language, region } = localeObject;
-		if (customMapping) for (const l of [
-			aliasedLocale,
-			locale,
-			standardizedLocale,
-			language
-		]) {
-			const customEmoji = getCustomProperty(customMapping, l, "emoji");
-			if (customEmoji) return customEmoji;
-		}
-		const regionEmoji = region && getSupportedRegionEmoji(region);
-		if (regionEmoji) return regionEmoji;
-		const extrapolated = localeObject.maximize();
-		return exceptions[extrapolated.language] || getRegionEmoji(extrapolated.region || "");
-	} 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 specialRegionEmojis = {
-	EU: "🇪🇺",
-	"419": "🌎"
-};
-const flagRegions = new Set([
-	"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"
-]);
-const regionalIndicatorOffset = 127462 - "A".charCodeAt(0);
-function getRegionEmoji(region) {
-	return getSupportedRegionEmoji(region) || "🌍";
-}
-function getSupportedRegionEmoji(region) {
-	const normalizedRegion = region.toUpperCase();
-	const specialEmoji = specialRegionEmojis[normalizedRegion];
-	if (specialEmoji) return specialEmoji;
-	if (!flagRegions.has(normalizedRegion)) return void 0;
-	return String.fromCodePoint(normalizedRegion.charCodeAt(0) + regionalIndicatorOffset, normalizedRegion.charCodeAt(1) + regionalIndicatorOffset);
-}
-//#endregion
-//#region src/locales/getLocaleProperties.ts
-/**
-* Creates a set of custom locale properties from a custom mapping.
-*
-* @param lArray - An array of locale codes to search for in the custom mapping.
-* @param customMapping - Optional custom mapping of locale codes to names.
-* @returns A partial set of locale properties, or undefined if no custom mapping is provided.
-*/
-function createCustomLocaleProperties(lArray, customMapping) {
-	if (customMapping) {
-		let merged = {};
-		for (const l of lArray) {
-			const value = customMapping[l];
-			if (value) {
-				if (typeof value === "string") merged.name ||= value;
-				else if (value) merged = {
-					...value,
-					...merged
-				};
-			}
-		}
-		return merged;
-	}
-}
-/**
-* @internal
-*/
-function _getLocaleProperties(locale, defaultLocale = "en", customMapping) {
-	const aliasedLocale = locale;
-	if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) locale = customMapping[locale].code;
-	defaultLocale ||= "en";
-	try {
-		const standardizedLocale = _standardizeLocale(locale);
-		const localeObject = require_IntlCache.intlCache.get("Locale", locale);
-		const languageCode = localeObject.language;
-		const customLocaleProperties = createCustomLocaleProperties([
-			aliasedLocale,
-			locale,
-			standardizedLocale,
-			languageCode
-		], customMapping);
-		const baseRegion = localeObject.region;
-		const maximizedLocale = localeObject.maximize();
-		const maximizedCode = maximizedLocale.toString();
-		const regionCode = localeObject.region || customLocaleProperties?.regionCode || maximizedLocale.region || "";
-		const scriptCode = localeObject.script || customLocaleProperties?.scriptCode || maximizedLocale.script || "";
-		const minimizedCode = localeObject.minimize().toString();
-		const defaultLanguageOrder = [
-			defaultLocale,
-			locale,
-			"en"
-		];
-		const nativeLanguageOrder = [
-			locale,
-			defaultLocale,
-			"en"
-		];
-		const languageNames = require_IntlCache.intlCache.get("DisplayNames", defaultLanguageOrder, { type: "language" });
-		const nativeLanguageNames = require_IntlCache.intlCache.get("DisplayNames", nativeLanguageOrder, { type: "language" });
-		const customName = customLocaleProperties?.name;
-		const customNativeName = customLocaleProperties?.nativeName || customLocaleProperties?.name;
-		const name = customName || languageNames.of(locale) || locale;
-		const nativeName = customNativeName || nativeLanguageNames.of(locale) || locale;
-		const maximizedName = customLocaleProperties?.maximizedName || customName || languageNames.of(maximizedCode) || locale;
-		const nativeMaximizedName = customLocaleProperties?.nativeMaximizedName || customNativeName || nativeLanguageNames.of(maximizedCode) || locale;
-		const minimizedName = customLocaleProperties?.minimizedName || customName || languageNames.of(minimizedCode) || locale;
-		const nativeMinimizedName = customLocaleProperties?.nativeMinimizedName || customNativeName || nativeLanguageNames.of(minimizedCode) || locale;
-		const languageName = customLocaleProperties?.languageName || customName || languageNames.of(languageCode) || locale;
-		const nativeLanguageName = customLocaleProperties?.nativeLanguageName || customNativeName || nativeLanguageNames.of(languageCode) || locale;
-		const nameWithRegionCode = customLocaleProperties?.nameWithRegionCode || baseRegion ? `${languageName} (${baseRegion})` : name;
-		const nativeNameWithRegionCode = customLocaleProperties?.nativeNameWithRegionCode || (baseRegion ? `${nativeLanguageName} (${baseRegion})` : nativeName) || nameWithRegionCode;
-		const regionNames = require_IntlCache.intlCache.get("DisplayNames", defaultLanguageOrder, { type: "region" });
-		const nativeRegionNames = require_IntlCache.intlCache.get("DisplayNames", nativeLanguageOrder, { type: "region" });
-		const regionName = customLocaleProperties?.regionName || (regionCode ? regionNames.of(regionCode) : "") || "";
-		const nativeRegionName = customLocaleProperties?.nativeRegionName || (regionCode ? nativeRegionNames.of(regionCode) : "") || "";
-		const scriptNames = require_IntlCache.intlCache.get("DisplayNames", defaultLanguageOrder, { type: "script" });
-		const nativeScriptNames = require_IntlCache.intlCache.get("DisplayNames", nativeLanguageOrder, { type: "script" });
-		return {
-			code: standardizedLocale,
-			name,
-			nativeName,
-			maximizedCode,
-			maximizedName,
-			nativeMaximizedName,
-			minimizedCode,
-			minimizedName,
-			nativeMinimizedName,
-			languageCode,
-			languageName,
-			nativeLanguageName,
-			nameWithRegionCode,
-			nativeNameWithRegionCode,
-			regionCode,
-			regionName,
-			nativeRegionName,
-			scriptCode,
-			scriptName: customLocaleProperties?.scriptName || (scriptCode ? scriptNames.of(scriptCode) : "") || "",
-			nativeScriptName: customLocaleProperties?.nativeScriptName || (scriptCode ? nativeScriptNames.of(scriptCode) : "") || "",
-			emoji: customLocaleProperties?.emoji || _getLocaleEmoji(standardizedLocale, customMapping)
-		};
-	} catch {
-		let code = _isValidLocale(locale) ? _standardizeLocale(locale) : locale;
-		const codeParts = code?.split("-");
-		let languageCode = codeParts?.[0] || code || "";
-		let regionCode = codeParts.length > 2 ? codeParts?.[2] : codeParts?.[1] || "";
-		let scriptCode = codeParts?.[3] || "";
-		const customLocaleProperties = createCustomLocaleProperties([code, languageCode], customMapping);
-		code = customLocaleProperties?.code || code;
-		const name = customLocaleProperties?.name || code;
-		const nativeName = customLocaleProperties?.nativeName || name;
-		const maximizedCode = customLocaleProperties?.maximizedCode || code;
-		const maximizedName = customLocaleProperties?.maximizedName || name;
-		const nativeMaximizedName = customLocaleProperties?.nativeMaximizedName || nativeName;
-		const minimizedCode = customLocaleProperties?.minimizedCode || code;
-		const minimizedName = customLocaleProperties?.minimizedName || name;
-		const nativeMinimizedName = customLocaleProperties?.nativeMinimizedName || nativeName;
-		languageCode = customLocaleProperties?.languageCode || languageCode;
-		const languageName = customLocaleProperties?.languageName || name;
-		const nativeLanguageName = customLocaleProperties?.nativeLanguageName || nativeName;
-		regionCode = customLocaleProperties?.regionCode || regionCode;
-		const regionName = customLocaleProperties?.regionName || "";
-		const nativeRegionName = customLocaleProperties?.nativeRegionName || "";
-		scriptCode = customLocaleProperties?.scriptCode || scriptCode;
-		const scriptName = customLocaleProperties?.scriptName || "";
-		const nativeScriptName = customLocaleProperties?.nativeScriptName || "";
-		const nameWithRegionCode = customLocaleProperties?.nameWithRegionCode || (regionName ? `${languageName} (${regionName})` : name);
-		const nativeNameWithRegionCode = customLocaleProperties?.nativeNameWithRegionCode || (nativeRegionName ? `${nativeLanguageName} (${nativeRegionName})` : nativeName);
-		const emoji = customLocaleProperties?.emoji || "🌍";
-		return {
-			code,
-			name,
-			nativeName,
-			maximizedCode,
-			maximizedName,
-			nativeMaximizedName,
-			minimizedCode,
-			minimizedName,
-			nativeMinimizedName,
-			languageCode,
-			languageName,
-			nativeLanguageName,
-			nameWithRegionCode,
-			nativeNameWithRegionCode,
-			regionCode,
-			regionName,
-			nativeRegionName,
-			scriptCode,
-			scriptName,
-			nativeScriptName,
-			emoji
-		};
-	}
-}
-//#endregion
-//#region src/locales/determineLocale.ts
-/**
-* Given a list of locales and a list of approved locales, sorted in preference order
-* Determines which locale is the best match among the approved locales, prioritizing exact matches and falling back to dialects of the same language
-* @internal
-*/
-function _determineLocale(locales, approvedLocales, customMapping) {
-	if (typeof locales === "string") locales = [locales];
-	locales = locales.filter((locale) => _isValidLocale(locale, customMapping)).map(_standardizeLocale);
-	approvedLocales = approvedLocales.filter((locale) => _isValidLocale(locale, customMapping)).map(_standardizeLocale);
-	for (const locale of locales) {
-		const candidates = approvedLocales.filter((approvedLocale) => _isSameLanguage(locale, approvedLocale));
-		const getMatchingCode = ({ locale, languageCode, minimizedCode, regionCode, scriptCode }) => {
-			const locales = [
-				locale,
-				`${languageCode}-${regionCode}`,
-				`${languageCode}-${scriptCode}`,
-				minimizedCode
-			];
-			for (const l of locales) if (candidates.includes(l)) return l;
-			return null;
-		};
-		const { languageCode, ...codes } = _getLocaleProperties(locale);
-		const matchingCode = getMatchingCode({
-			locale,
-			languageCode,
-			...codes
-		}) || getMatchingCode({
-			locale: languageCode,
-			..._getLocaleProperties(languageCode)
-		});
-		if (matchingCode) return matchingCode;
-	}
-}
-//#endregion
-//#region src/logging/logger.ts
-const LOG_LEVELS = {
-	debug: 0,
-	info: 1,
-	warn: 2,
-	error: 3,
-	off: 4
-};
-const LOG_COLORS = {
-	debug: "\x1B[36m",
-	info: "\x1B[32m",
-	warn: "\x1B[33m",
-	error: "\x1B[31m",
-	off: ""
-};
-const RESET_COLOR = "\x1B[0m";
-/**
-* Get the configured log level from environment variable or default to 'warn'
-*/
-function getConfiguredLogLevel() {
-	if (typeof process !== "undefined" && process.env?._GT_LOG_LEVEL) {
-		const envLevel = process.env._GT_LOG_LEVEL.toLowerCase();
-		if (envLevel in LOG_LEVELS) return envLevel;
-	}
-	return "warn";
-}
-/**
-* Console log handler that outputs formatted messages to console
-*/
-var ConsoleLogHandler = class {
-	constructor(config) {
-		this.config = config;
-	}
-	handle(entry) {
-		const parts = [];
-		if (this.config.includeTimestamp) parts.push(`[${entry.timestamp.toISOString()}]`);
-		const colorCode = LOG_COLORS[entry.level];
-		const levelText = `[${entry.level.toUpperCase()}]`;
-		parts.push(`${colorCode}${levelText}${RESET_COLOR}`);
-		if (this.config.prefix) parts.push(`[${this.config.prefix}]`);
-		if (this.config.includeContext && entry.context) parts.push(`[${entry.context}]`);
-		parts.push(entry.message);
-		if (entry.metadata && Object.keys(entry.metadata).length > 0) parts.push(`\n  Metadata: ${JSON.stringify(entry.metadata, null, 2)}`);
-		const formattedMessage = parts.join(" ");
-		switch (entry.level) {
-			case "debug":
-				console.debug(formattedMessage);
-				break;
-			case "info":
-				console.info(formattedMessage);
-				break;
-			case "warn":
-				console.warn(formattedMessage);
-				break;
-			case "error":
-				console.error(formattedMessage);
-				break;
-		}
-	}
-};
-/**
-* Main Logger class providing structured logging capabilities.
-*/
-var Logger = class {
-	constructor(config = {}) {
-		this.config = {
-			level: getConfiguredLogLevel(),
-			includeTimestamp: true,
-			includeContext: true,
-			enableConsole: true,
-			handlers: [],
-			...config
-		};
-		this.handlers = [...this.config.handlers || []];
-		if (this.config.enableConsole) this.handlers.push(new ConsoleLogHandler(this.config));
-	}
-	/**
-	* Add a custom log handler
-	*/
-	addHandler(handler) {
-		this.handlers.push(handler);
-	}
-	/**
-	* Remove a log handler
-	*/
-	removeHandler(handler) {
-		const index = this.handlers.indexOf(handler);
-		if (index > -1) this.handlers.splice(index, 1);
-	}
-	/**
-	* Update logger configuration
-	*/
-	configure(config) {
-		this.config = {
-			...this.config,
-			...config
-		};
-	}
-	/**
-	* Check if a log level should be output based on current configuration
-	*/
-	shouldLog(level) {
-		return LOG_LEVELS[level] >= LOG_LEVELS[this.config.level];
-	}
-	/**
-	* Internal logging method that creates log entries and passes them to handlers
-	*/
-	log(level, message, context, metadata) {
-		if (!this.shouldLog(level)) return;
-		const entry = {
-			level,
-			message,
-			timestamp: /* @__PURE__ */ new Date(),
-			context,
-			metadata
-		};
-		this.handlers.forEach((handler) => {
-			try {
-				handler.handle(entry);
-			} catch (error) {
-				console.error("Error in log handler:", error);
-			}
-		});
-	}
-	/**
-	* Log a debug message
-	* Used for detailed diagnostic information, typically of interest only when diagnosing problems
-	*/
-	debug(message, context, metadata) {
-		this.log("debug", message, context, metadata);
-	}
-	/**
-	* Log an info message
-	* Used for general information about application operation.
-	*/
-	info(message, context, metadata) {
-		this.log("info", message, context, metadata);
-	}
-	/**
-	* Log a warning message
-	* Used for potentially problematic situations that don't prevent operation
-	*/
-	warn(message, context, metadata) {
-		this.log("warn", message, context, metadata);
-	}
-	/**
-	* Log an error message
-	* Used for error events that might still allow the application to continue.
-	*/
-	error(message, context, metadata) {
-		this.log("error", message, context, metadata);
-	}
-	/**
-	* Create a child logger with a specific context
-	*/
-	child(context) {
-		return new ContextLogger(this, context);
-	}
-	/**
-	* Get current logger configuration
-	*/
-	getConfig() {
-		return { ...this.config };
-	}
-};
-/**
-* Context logger that automatically includes context information.
-*/
-var ContextLogger = class ContextLogger {
-	constructor(logger, context) {
-		this.logger = logger;
-		this.context = context;
-	}
-	debug(message, metadata) {
-		this.logger.debug(message, this.context, metadata);
-	}
-	info(message, metadata) {
-		this.logger.info(message, this.context, metadata);
-	}
-	warn(message, metadata) {
-		this.logger.warn(message, this.context, metadata);
-	}
-	error(message, metadata) {
-		this.logger.error(message, this.context, metadata);
-	}
-	child(childContext) {
-		return new ContextLogger(this.logger, `${this.context}:${childContext}`);
-	}
-};
-const defaultLogger = new Logger({
-	level: getConfiguredLogLevel(),
-	includeTimestamp: true,
-	includeContext: true,
-	prefix: "GT"
-});
-const fetchLogger = defaultLogger.child("fetch");
-defaultLogger.child("validation");
-defaultLogger.child("formatting");
-defaultLogger.child("locale");
-const gtInstanceLogger = defaultLogger.child("GT instance");
-//#endregion
-//#region src/formatting/format.ts
-/**
-* Formats a string value with cutoff behavior according to the specified locales and options.
-*
-* @param {Object} params - The parameters for the cutoff formatting.
-* @param {string} params.value - The string value to format with cutoff behavior.
-* @param {string | string[]} [params.locales='en'] - The locales to use for formatting.
-* @param {CutoffFormatOptions} [params.options={}] - Additional options for cutoff formatting.
-* @param {number} [params.options.maxChars] - The maximum number of characters to display.
-* @param {CutoffFormatStyle} [params.options.style='ellipsis'] - The style of the terminator.
-* @param {string} [params.options.terminator] - Optional override for the terminator to use.
-* @param {string} [params.options.separator] - Optional override for the separator between terminator and value.
-*
-* @returns {string} The formatted string with terminator applied if cutoff occurs.
-* @internal
-*
-* @example
-* _formatCutoff({ value: 'Hello, world!', options: { maxChars: 8 } }); // Returns 'Hello, w...'
-*/
-function _formatCutoff({ value, locales = "en", options = {} }) {
-	return require_IntlCache.intlCache.get("CutoffFormat", locales, options).format(value);
-}
-/**
-* Formats a message according to the specified locales and options.
-*
-* @param {string} message - The message to format.
-* @param {string | string[]} [locales='en'] - The locales to use for formatting.
-* @param {Record<string, any>} [variables={}] - The variables to use for formatting.
-* @returns {string} The formatted message.
-* @internal
-*
-* Returns an empty string if IntlMessageFormat produces no output.
-* TODO: Add this to custom formats.
-*/
-function _formatMessageICU(message, locales = "en", variables = {}) {
-	return new intl_messageformat.IntlMessageFormat(message, locales).format(variables)?.toString() ?? "";
-}
-/**
-* Returns the message as-is without any formatting.
-*
-* @param {string} message - The message to return.
-* @returns {string} The original message, unchanged.
-* @internal
-*
-* TODO: Add this to custom formats.
-*/
-function _formatMessageString(message) {
-	return message;
-}
-/**
-* Formats a number according to the specified locales and options.
-*
-* @param {Object} params - The parameters for the number formatting.
-* @param {number} params.value - The number to format.
-* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
-* @param {Intl.NumberFormatOptions} [params.options={}] - Additional options for number formatting.
-*
-* @returns {string} The formatted number.
-* @internal
-*/
-function _formatNum({ value, locales = ["en"], options = {} }) {
-	return require_IntlCache.intlCache.get("NumberFormat", locales, {
-		numberingSystem: "latn",
-		...options
-	}).format(value);
-}
-/**
-* Formats a date according to the specified locales and options.
-*
-* @param {Object} params - The parameters for the date formatting.
-* @param {Date} params.value - The date to format.
-* @param {string | string[]} [params.locales='en'] - The locales to use for formatting.
-* @param {Intl.DateTimeFormatOptions} [params.options={}] - Additional options for date formatting.
-*
-* @returns {string} The formatted date.
-* @internal
-*/
-function _formatDateTime({ value, locales = ["en"], options = {} }) {
-	return require_IntlCache.intlCache.get("DateTimeFormat", locales, {
-		calendar: "gregory",
-		numberingSystem: "latn",
-		...options
-	}).format(value);
-}
-/**
-* Formats a currency value according to the specified locales, currency, and options.
-*
-* @param {Object} params - The parameters for the currency formatting.
-* @param {number} params.value - The currency value to format.
-* @param {string} params.currency - The currency code (e.g., 'USD').
-* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
-* @param {Intl.NumberFormatOptions} [params.options={}] - Additional options for currency formatting.
-*
-* @returns {string} The formatted currency value.
-* @internal
-*/
-function _formatCurrency({ value, locales = ["en"], currency = "USD", options = {} }) {
-	return require_IntlCache.intlCache.get("NumberFormat", locales, {
-		style: "currency",
-		currency,
-		numberingSystem: "latn",
-		...options
-	}).format(value);
-}
-/**
-* Formats a list of items according to the specified locales and options.
-*
-* @param {Object} params - The parameters for the list formatting.
-* @param {Array<string | number>} params.value - The list of items to format.
-* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
-* @param {Intl.ListFormatOptions} [params.options={}] - Additional options for list formatting.
-*
-* @returns {string} The formatted list.
-* @internal
-*/
-function _formatList({ value, locales = ["en"], options = {} }) {
-	return require_IntlCache.intlCache.get("ListFormat", locales, {
-		type: "conjunction",
-		style: "long",
-		...options
-	}).format(value.map(String));
-}
-/**
-* Formats a list of items according to the specified locales and options.
-* @param {Object} params - The parameters for the list formatting.
-* @param {Array<T>} params.value - The list of items to format.
-* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
-* @param {Intl.ListFormatOptions} [params.options={}] - Additional options for list formatting.
-* @returns {Array<T | string>} The formatted list parts.
-* @internal
-*/
-function _formatListToParts({ value, locales = ["en"], options = {} }) {
-	const formatListParts = require_IntlCache.intlCache.get("ListFormat", locales, {
-		type: "conjunction",
-		style: "long",
-		...options
-	}).formatToParts(value.map(() => "1"));
-	let partIndex = 0;
-	return formatListParts.map((part) => {
-		if (part.type === "element") return value[partIndex++];
-		return part.value;
-	});
-}
-/**
-* Selects the best unit and computes the value for relative time formatting
-* based on the difference between a date and a base date.
-* @param {Date} date - The target date.
-* @param {Date} baseDate - The base date to compute relative time from. Must be provided by the caller for hydration safety.
-* @returns {{ value: number, unit: Intl.RelativeTimeFormatUnit }} The computed value and unit.
-* @internal
-*/
-function _selectRelativeTimeUnit(date, baseDate) {
-	const now = baseDate.getTime();
-	const diffMs = date.getTime() - now;
-	const absDiffMs = Math.abs(diffMs);
-	const sign = diffMs < 0 ? -1 : 1;
-	const seconds = Math.floor(absDiffMs / 1e3);
-	const minutes = Math.floor(absDiffMs / (1e3 * 60));
-	const hours = Math.floor(absDiffMs / (1e3 * 60 * 60));
-	const days = Math.floor(absDiffMs / (1e3 * 60 * 60 * 24));
-	const weeks = Math.floor(absDiffMs / (1e3 * 60 * 60 * 24 * 7));
-	const months = Math.floor(absDiffMs / (1e3 * 60 * 60 * 24 * 30));
-	const years = Math.floor(absDiffMs / (1e3 * 60 * 60 * 24 * 365));
-	if (seconds < 60) return {
-		value: sign * seconds,
-		unit: "second"
-	};
-	if (minutes < 60) return {
-		value: sign * minutes,
-		unit: "minute"
-	};
-	if (hours < 24) return {
-		value: sign * hours,
-		unit: "hour"
-	};
-	if (days < 7) return {
-		value: sign * days,
-		unit: "day"
-	};
-	if (days < 28) return {
-		value: sign * weeks,
-		unit: "week"
-	};
-	if (months < 1) return {
-		value: sign * weeks,
-		unit: "week"
-	};
-	if (months < 12) return {
-		value: sign * months,
-		unit: "month"
-	};
-	if (years < 1) return {
-		value: sign * months,
-		unit: "month"
-	};
-	return {
-		value: sign * years,
-		unit: "year"
-	};
-}
-/**
-* Formats a relative time from a Date, automatically selecting the best unit.
-* @internal
-*/
-function _formatRelativeTimeFromDate({ date, baseDate, locales = ["en"], options = {} }) {
-	const { value, unit } = _selectRelativeTimeUnit(date, baseDate);
-	return _formatRelativeTime({
-		value,
-		unit,
-		locales,
-		options
-	});
-}
-/**
-* Formats a relative time value according to the specified locales and options.
-*
-* @param {Object} params - The parameters for the relative time formatting.
-* @param {number} params.value - The relative time value to format.
-* @param {Intl.RelativeTimeFormatUnit} params.unit - The unit of time (e.g., 'second', 'minute', 'hour', 'day', 'week', 'month', 'year').
-* @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
-* @param {Intl.RelativeTimeFormatOptions} [params.options={}] - Additional options for relative time formatting.
-*
-* @returns {string} The formatted relative time string.
-* @internal
-*/
-function _formatRelativeTime({ value, unit, locales = ["en"], options = {} }) {
-	return require_IntlCache.intlCache.get("RelativeTimeFormat", locales, {
-		style: "long",
-		numeric: "auto",
-		...options
-	}).format(value, unit);
-}
-//#endregion
-//#region src/locales/getLocaleName.ts
-/**
-* Retrieves the display name(s) of locale code(s) using Intl.DisplayNames.
-*
-* @param {string} locale - A BCP-47 locale code.
-* @param {string} [defaultLocale=libraryDefaultLocale] - The locale for display names.
-* @returns {string} The display name(s) corresponding to the code(s), or empty string(s) if invalid.
-* @internal
-*/
-function _getLocaleName(locale, defaultLocale = "en", customMapping) {
-	const aliasedLocale = locale;
-	if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) locale = customMapping[locale].code;
-	defaultLocale ||= "en";
-	try {
-		const standardizedLocale = _standardizeLocale(locale);
-		if (customMapping) for (const l of [
-			aliasedLocale,
-			locale,
-			standardizedLocale,
-			require_IntlCache.intlCache.get("Locale", standardizedLocale).language
-		]) {
-			const customName = getCustomProperty(customMapping, l, "name");
-			if (customName) return customName;
-		}
-		return require_IntlCache.intlCache.get("DisplayNames", [
-			defaultLocale,
-			standardizedLocale,
-			"en"
-		], { type: "language" }).of(standardizedLocale) || "";
-	} catch {
-		return "";
-	}
-}
-//#endregion
-//#region src/locales/getLocaleDirection.ts
-/**
-* Get the text direction for a given locale code using the Intl.Locale API.
-*
-* @param {string} code - The locale code to check.
-* @returns {string} 'rtl' if the language is right-to-left; otherwise 'ltr'.
-* @internal
-*/
-function _getLocaleDirection(code) {
-	try {
-		const textInfoDirection = extractDirectionWithTextInfo(require_IntlCache.intlCache.get("Locale", code));
-		if (textInfoDirection) return textInfoDirection;
-	} catch {}
-	const { scriptCode, languageCode } = _getLocaleProperties(code);
-	if (scriptCode) return isRtlScript(scriptCode) ? "rtl" : "ltr";
-	if (languageCode) return isRtlLanguage(languageCode) ? "rtl" : "ltr";
-	return "ltr";
-}
-const RTL_SCRIPTS = new Set([
-	"arab",
-	"adlm",
-	"hebr",
-	"nkoo",
-	"rohg",
-	"samr",
-	"syrc",
-	"thaa",
-	"yezi"
-]);
-const RTL_LANGUAGES = new Set([
-	"ar",
-	"arc",
-	"ckb",
-	"dv",
-	"fa",
-	"he",
-	"iw",
-	"ku",
-	"lrc",
-	"nqo",
-	"ps",
-	"pnb",
-	"sd",
-	"syr",
-	"ug",
-	"ur",
-	"yi"
-]);
-/**
-* Handles extracting direction via textInfo property
-* @param locale - Intl.Locale object.
-* @returns {'ltr' | 'rtl'} - The direction of the locale
-*
-* Intl.Locale.prototype.getTextInfo() / textInfo property incorporated in ES2024 Specification.
-* This is not supported by all browsers yet.
-* See: {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/getTextInfo#browser_compatibility}
-*/
-function extractDirectionWithTextInfo(locale) {
-	if ("textInfo" in locale && typeof locale.textInfo === "object" && locale.textInfo !== null && "direction" in locale.textInfo && (locale.textInfo?.direction === "rtl" || locale.textInfo?.direction === "ltr")) return locale.textInfo?.direction;
-}
-function isRtlScript(script) {
-	return script ? RTL_SCRIPTS.has(script.toLowerCase()) : false;
-}
-function isRtlLanguage(language) {
-	return language ? RTL_LANGUAGES.has(language.toLowerCase()) : false;
-}
-//#endregion
-//#region src/locales/isSupersetLocale.ts
-/**
-* @internal
-*/
-function _isSupersetLocale(superLocale, subLocale) {
-	try {
-		const { language: languageSuper, region: regionSuper, script: scriptSuper } = require_IntlCache.intlCache.get("Locale", _standardizeLocale(superLocale));
-		const { language: languageSub, region: regionSub, script: scriptSub } = require_IntlCache.intlCache.get("Locale", _standardizeLocale(subLocale));
-		if (languageSuper !== languageSub) return false;
-		if (regionSuper && regionSuper !== regionSub) return false;
-		if (scriptSuper && scriptSuper !== scriptSub) return false;
-		return true;
-	} catch (error) {
-		console.error(error);
-		return false;
-	}
-}
-//#endregion
-//#region src/locales/resolveAliasLocale.ts
-/**
-* Resolves the alias locale for a given locale.
-* @param locale - The locale to resolve the alias locale for
-* @param customMapping - The custom mapping to use for resolving the alias locale
-* @returns The configured alias for a canonical locale, or the input locale when already an alias or no alias mapping exists.
-*/
-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, or the input locale when no canonical mapping exists.
-*/
-function _resolveCanonicalLocale(locale, customMapping) {
-	if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) return customMapping[locale].code;
-	return locale;
-}
-//#endregion
-//#region src/LocaleConfig.ts
-/**
-* LocaleConfig contains the locale and formatting primitives exposed through
-* the core entrypoint.
-*
-* It intentionally does not store project IDs, API keys, runtime URLs, or any
-* translation credentials. It only stores locale metadata needed to resolve
-* aliases, choose formatting fallbacks, and format values with Intl.
-*/
-var LocaleConfig = class {
-	constructor({ defaultLocale = "en", locales = [], customMapping } = {}) {
-		this.defaultLocale = defaultLocale;
-		this.locales = locales;
-		this.customMapping = customMapping;
-	}
-	get translationLocales() {
-		return this.locales.length ? this.locales : void 0;
-	}
-	resolveCanonicalLocaleList(locales) {
-		return locales.map((locale) => this.resolveCanonicalLocale(locale));
-	}
-	resolveCanonicalLocaleArgs(locales) {
-		return locales.map((locale) => Array.isArray(locale) ? this.resolveCanonicalLocaleList(locale) : this.resolveCanonicalLocale(locale));
-	}
-	toLocaleList(locales) {
-		return Array.isArray(locales) ? locales : [locales];
-	}
-	getFormattingLocales(targetLocale, locales) {
-		return (locales !== void 0 ? this.toLocaleList(locales) : [
-			targetLocale,
-			this.defaultLocale,
-			"en"
-		]).filter((locale) => !!locale).map((locale) => this.resolveCanonicalLocale(locale));
-	}
-	formatNum(value, targetLocale, options = {}) {
-		const { locales, ...intlOptions } = options;
-		return _formatNum({
-			value,
-			locales: this.getFormattingLocales(targetLocale, locales),
-			options: intlOptions
-		});
-	}
-	formatDateTime(value, targetLocale, options = {}) {
-		const { locales, ...intlOptions } = options;
-		return _formatDateTime({
-			value,
-			locales: this.getFormattingLocales(targetLocale, locales),
-			options: intlOptions
-		});
-	}
-	formatCurrency(value, currency, targetLocale, options = {}) {
-		const { locales, ...intlOptions } = options;
-		return _formatCurrency({
-			value,
-			currency,
-			locales: this.getFormattingLocales(targetLocale, locales),
-			options: intlOptions
-		});
-	}
-	formatRelativeTime(value, unit, targetLocale, options = {}) {
-		const { locales, ...intlOptions } = options;
-		return _formatRelativeTime({
-			value,
-			unit,
-			locales: this.getFormattingLocales(targetLocale, locales),
-			options: intlOptions
-		});
-	}
-	formatRelativeTimeFromDate(date, targetLocale, options = {}) {
-		const { locales, baseDate, ...intlOptions } = options;
-		return _formatRelativeTimeFromDate({
-			date,
-			baseDate: baseDate ?? /* @__PURE__ */ new Date(),
-			locales: this.getFormattingLocales(targetLocale, locales),
-			options: intlOptions
-		});
-	}
-	formatCutoff(value, targetLocale, options = {}) {
-		const { locales, ...formatOptions } = options;
-		return _formatCutoff({
-			value,
-			locales: this.getFormattingLocales(targetLocale, locales),
-			options: formatOptions
-		});
-	}
-	formatMessage(message, targetLocale, options = {}) {
-		const { locales, variables, dataFormat } = options;
-		if (dataFormat === "STRING") return _formatMessageString(message);
-		return _formatMessageICU(message, this.getFormattingLocales(targetLocale, locales), variables);
-	}
-	formatList(array, targetLocale, options = {}) {
-		const { locales, ...intlOptions } = options;
-		return _formatList({
-			value: array,
-			locales: this.getFormattingLocales(targetLocale, locales),
-			options: intlOptions
-		});
-	}
-	formatListToParts(array, targetLocale, options = {}) {
-		const { locales, ...intlOptions } = options;
-		return _formatListToParts({
-			value: array,
-			locales: this.getFormattingLocales(targetLocale, locales),
-			options: intlOptions
-		});
-	}
-	getLocaleName(locale) {
-		return _getLocaleName(locale, this.defaultLocale, this.customMapping);
-	}
-	getLocaleEmoji(locale) {
-		return _getLocaleEmoji(locale, this.customMapping);
-	}
-	getLocaleProperties(locale) {
-		return _getLocaleProperties(locale, this.defaultLocale, this.customMapping);
-	}
-	requiresTranslation(targetLocale, sourceLocale = this.defaultLocale, approvedLocales = this.translationLocales) {
-		return _requiresTranslation(this.resolveCanonicalLocale(sourceLocale), this.resolveCanonicalLocale(targetLocale), approvedLocales ? this.resolveCanonicalLocaleList(approvedLocales) : void 0, this.customMapping);
-	}
-	determineLocale(locales, approvedLocales = this.locales) {
-		const approvedLocalePairs = approvedLocales.map((locale) => ({
-			locale,
-			canonicalLocale: this.resolveCanonicalLocale(locale)
-		}));
-		const resolvedLocale = _determineLocale(Array.isArray(locales) ? this.resolveCanonicalLocaleList(locales) : this.resolveCanonicalLocale(locales), approvedLocalePairs.map(({ canonicalLocale }) => canonicalLocale), this.customMapping);
-		if (!resolvedLocale) return void 0;
-		return approvedLocalePairs.find(({ canonicalLocale }) => canonicalLocale === resolvedLocale)?.locale || this.resolveAliasLocale(resolvedLocale);
-	}
-	getLocaleDirection(locale) {
-		return _getLocaleDirection(this.resolveCanonicalLocale(locale));
-	}
-	isValidLocale(locale) {
-		return _isValidLocale(locale, this.customMapping);
-	}
-	resolveCanonicalLocale(locale) {
-		return _resolveCanonicalLocale(locale, this.customMapping);
-	}
-	resolveAliasLocale(locale) {
-		return _resolveAliasLocale(locale, this.customMapping);
-	}
-	standardizeLocale(locale) {
-		return _standardizeLocale(locale);
-	}
-	isSameDialect(...locales) {
-		return _isSameDialect(...this.resolveCanonicalLocaleArgs(locales));
-	}
-	isSameLanguage(...locales) {
-		return _isSameLanguage(...this.resolveCanonicalLocaleArgs(locales));
-	}
-	isSupersetLocale(superLocale, subLocale) {
-		return _isSupersetLocale(this.resolveCanonicalLocale(superLocale), this.resolveCanonicalLocale(subLocale));
-	}
-};
-//#endregion
-//#region src/core.ts
-/**
-* Core formatting and locale helpers.
-*
-* This entry point exposes deterministic locale and formatting primitives. It
-* does not export the GT service client, project credentials, network
-* translation methods, file APIs, or other server/service concerns from the
-* root `generaltranslation` facade.
-*
-* This entry point is intended for framework and shared packages that need
-* locale metadata or formatting behavior without pulling in the full
-* translation API surface.
-*/
-/**
-* Formats a string with cutoff behavior, applying a terminator when the string exceeds the maximum character limit.
-*
-* This standalone function provides cutoff formatting functionality without requiring a GT instance.
-* The locales parameter is required for proper terminator selection based on the target language.
-*
-* @param {string} value - The string value to format with cutoff behavior.
-* @param {Object} [options] - Configuration options for cutoff formatting.
-* @param {string | string[]} [options.locales] - The locales to use for terminator selection.
-* @param {number} [options.maxChars] - The maximum number of characters to display.
-* - Undefined values are treated as no cutoff.
-* - Negative values follow .slice() behavior and terminator will be added before the value.
-* - 0 will result in an empty string.
-* - If cutoff results in an empty string, no terminator is added.
-* @param {CutoffFormatStyle} [options.style='ellipsis'] - The style of the terminator.
-* @param {string} [options.terminator] - Optional override the terminator to use.
-* @param {string} [options.separator] - Optional override the separator to use between the terminator and the value.
-* - If no terminator is provided, then separator is ignored.
-* @returns {string} The formatted string with terminator applied if cutoff occurs.
-*
-* @example
-* formatCutoff('Hello, world!', { locales: 'en-US', maxChars: 8 });
-* // Returns: 'Hello, …'
-*
-* @example
-* formatCutoff('Hello, world!', { locales: 'en-US', maxChars: -3 });
-* // Returns: '…d!'
-*
-* @example
-* formatCutoff('Very long text that needs cutting', {
-*   locales: 'en-US',
-*   maxChars: 15,
-*   style: 'ellipsis',
-*   separator: ' '
-* });
-* // Returns: 'Very long tex …'
-*/
-function formatCutoff(value, options) {
-	return _formatCutoff({
-		value,
-		locales: options?.locales,
-		options
-	});
-}
-/**
-* Formats a message according to the specified locales and options.
-*
-* @param {string} message - The message to format.
-* @param {Object} [options] - Configuration options for message formatting.
-* @param {string | string[]} [options.locales] - The locales to use for formatting.
-* @param {FormatVariables} [options.variables] - The variables to use for formatting.
-* @param {StringFormat} [options.dataFormat='ICU'] - The format of the message. When STRING, the message is returned as is.
-* @returns {string} The formatted message.
-*
-* @example
-* formatMessage('Hello {name}', { variables: { name: 'John' } });
-* // Returns: "Hello John"
-*
-* @example
-* formatMessage('Hello {name}', {
-*   locales: ['fr'],
-*   variables: { name: 'John' }
-* });
-*/
-function formatMessage(message, options) {
-	switch (options?.dataFormat) {
-		case "STRING": return _formatMessageString(message);
-		default: return _formatMessageICU(message, options?.locales, options?.variables);
-	}
-}
-/**
-* Checks if a given BCP 47 locale code is valid.
-*
-* @param {string} locale - The BCP 47 locale code to validate.
-* @param {CustomMapping} [customMapping] - The custom mapping to use for validation.
-* @returns {boolean} True if the BCP 47 code is valid, false otherwise.
-*
-* @example
-* isValidLocale('en-US');
-* // Returns: true
-*
-* @example
-* isValidLocale('en_US');
-* // Returns: false
-*/
-function isValidLocale(locale, customMapping) {
-	return _isValidLocale(locale, customMapping);
-}
-/**
-* Resolves the canonical locale for a given locale.
-*
-* @param {string} locale - The locale to resolve the canonical locale for.
-* @param {CustomMapping} [customMapping] - The custom mapping to use for resolving the canonical locale.
-* @returns {string} The canonical locale, or the input locale when no canonical mapping exists.
-*
-* @example
-* resolveCanonicalLocale('en-US');
-* // Returns: 'en-US'
-*
-* @example
-* resolveCanonicalLocale('en', { en: 'en-US' });
-* // Returns: 'en-US'
-*/
-function resolveCanonicalLocale(locale, customMapping) {
-	return _resolveCanonicalLocale(locale, customMapping);
-}
-/**
-* Standardizes a BCP 47 locale code to ensure correct formatting.
-*
-* @param {string} locale - The BCP 47 locale code to standardize.
-* @returns {string} The standardized BCP 47 locale code, or the input string if it cannot be standardized.
-*
-* @example
-* standardizeLocale('en-us');
-* // Returns: 'en-US'
-*
-* @example
-* standardizeLocale('not a locale');
-* // Returns: 'not a locale'
-*/
-function standardizeLocale(locale) {
-	return _standardizeLocale(locale);
-}
-//#endregion
-Object.defineProperty(exports, "LocaleConfig", {
-	enumerable: true,
-	get: function() {
-		return LocaleConfig;
-	}
-});
-Object.defineProperty(exports, "_determineLocale", {
-	enumerable: true,
-	get: function() {
-		return _determineLocale;
-	}
-});
-Object.defineProperty(exports, "_formatCurrency", {
-	enumerable: true,
-	get: function() {
-		return _formatCurrency;
-	}
-});
-Object.defineProperty(exports, "_formatDateTime", {
-	enumerable: true,
-	get: function() {
-		return _formatDateTime;
-	}
-});
-Object.defineProperty(exports, "_formatList", {
-	enumerable: true,
-	get: function() {
-		return _formatList;
-	}
-});
-Object.defineProperty(exports, "_formatListToParts", {
-	enumerable: true,
-	get: function() {
-		return _formatListToParts;
-	}
-});
-Object.defineProperty(exports, "_formatNum", {
-	enumerable: true,
-	get: function() {
-		return _formatNum;
-	}
-});
-Object.defineProperty(exports, "_formatRelativeTime", {
-	enumerable: true,
-	get: function() {
-		return _formatRelativeTime;
-	}
-});
-Object.defineProperty(exports, "_formatRelativeTimeFromDate", {
-	enumerable: true,
-	get: function() {
-		return _formatRelativeTimeFromDate;
-	}
-});
-Object.defineProperty(exports, "_getLocaleDirection", {
-	enumerable: true,
-	get: function() {
-		return _getLocaleDirection;
-	}
-});
-Object.defineProperty(exports, "_getLocaleEmoji", {
-	enumerable: true,
-	get: function() {
-		return _getLocaleEmoji;
-	}
-});
-Object.defineProperty(exports, "_getLocaleName", {
-	enumerable: true,
-	get: function() {
-		return _getLocaleName;
-	}
-});
-Object.defineProperty(exports, "_getLocaleProperties", {
-	enumerable: true,
-	get: function() {
-		return _getLocaleProperties;
-	}
-});
-Object.defineProperty(exports, "_isSameDialect", {
-	enumerable: true,
-	get: function() {
-		return _isSameDialect;
-	}
-});
-Object.defineProperty(exports, "_isSameLanguage", {
-	enumerable: true,
-	get: function() {
-		return _isSameLanguage;
-	}
-});
-Object.defineProperty(exports, "_isSupersetLocale", {
-	enumerable: true,
-	get: function() {
-		return _isSupersetLocale;
-	}
-});
-Object.defineProperty(exports, "_isValidLocale", {
-	enumerable: true,
-	get: function() {
-		return _isValidLocale;
-	}
-});
-Object.defineProperty(exports, "_requiresTranslation", {
-	enumerable: true,
-	get: function() {
-		return _requiresTranslation;
-	}
-});
-Object.defineProperty(exports, "_resolveAliasLocale", {
-	enumerable: true,
-	get: function() {
-		return _resolveAliasLocale;
-	}
-});
-Object.defineProperty(exports, "_resolveCanonicalLocale", {
-	enumerable: true,
-	get: function() {
-		return _resolveCanonicalLocale;
-	}
-});
-Object.defineProperty(exports, "_standardizeLocale", {
-	enumerable: true,
-	get: function() {
-		return _standardizeLocale;
-	}
-});
-Object.defineProperty(exports, "defaultEmoji", {
-	enumerable: true,
-	get: function() {
-		return defaultEmoji;
-	}
-});
-Object.defineProperty(exports, "fetchLogger", {
-	enumerable: true,
-	get: function() {
-		return fetchLogger;
-	}
-});
-Object.defineProperty(exports, "formatCutoff", {
-	enumerable: true,
-	get: function() {
-		return formatCutoff;
-	}
-});
-Object.defineProperty(exports, "formatMessage", {
-	enumerable: true,
-	get: function() {
-		return formatMessage;
-	}
-});
-Object.defineProperty(exports, "getRegionEmoji", {
-	enumerable: true,
-	get: function() {
-		return getRegionEmoji;
-	}
-});
-Object.defineProperty(exports, "gtInstanceLogger", {
-	enumerable: true,
-	get: function() {
-		return gtInstanceLogger;
-	}
-});
-Object.defineProperty(exports, "isValidLocale", {
-	enumerable: true,
-	get: function() {
-		return isValidLocale;
-	}
-});
-Object.defineProperty(exports, "resolveCanonicalLocale", {
-	enumerable: true,
-	get: function() {
-		return resolveCanonicalLocale;
-	}
-});
-Object.defineProperty(exports, "standardizeLocale", {
-	enumerable: true,
-	get: function() {
-		return standardizeLocale;
-	}
-});
-
-//# sourceMappingURL=core-7RP541eY.cjs.map